@milaboratories/pl-deployments 1.2.2 → 1.2.3

package/dist/index.mjs

@@ -1,46 +1,46 @@
-var Z = Object.defineProperty;
-var Y = (s, r, t) => r in s ? Z(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 y, assertNever as j, notEmpty as f, RetryablePromise as X } from "@milaboratories/ts-helpers";
+var Y = Object.defineProperty;
+var Q = (s, r, t) => r in s ? Y(s, r, { enumerable: !0, configurable: !0, writable: !0, value: t }) : s[r] = t;
+var w = (s, r, t) => Q(s, typeof r != "symbol" ? r + "" : r, t);
+import { spawn as X } from "node:child_process";
+import { sleep as F, fileExists as y, assertNever as H, notEmpty as f, RetryablePromise as tt } from "@milaboratories/ts-helpers";
 import D from "node:fs";
-import m, { readFile as tt } from "node:fs/promises";
+import m, { readFile as rt } from "node:fs/promises";
 import d from "upath";
-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 { request as et } from "undici";
+import { Readable as it, Writable as ot } from "node:stream";
+import { text as st } from "node:stream/consumers";
+import * as nt from "tar";
+import at 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 ct, { Client as b } from "ssh2";
+import M from "node:net";
+import lt from "node:dns";
 import { randomBytes as x } from "node:crypto";
-import { generateSshPlConfigs as lt, getFreePort as v } from "@milaboratories/pl-config";
+import { generateSshPlConfigs as ht, getFreePort as v } from "@milaboratories/pl-config";
 import { z as p } from "zod";
-function ht(s, r) {
+function dt(s, r) {
   return s.info(`Running:
 cmd: ${JSON.stringify([r.cmd, ...r.args])}
-wd: ${r.opts.cwd}`), s.info("  spawning child process"), Q(r.cmd, r.args, r.opts);
+wd: ${r.opts.cwd}`), s.info("  spawning child process"), X(r.cmd, r.args, r.opts);
 }
-async function O(s) {
+async function k(s) {
   try {
     return process.kill(s, 0), !0;
   } catch {
     return !1;
   }
 }
-function J(s) {
+function G(s) {
   return process.kill(s, "SIGINT");
 }
-async function M(s, r) {
+async function J(s, r) {
   let e = 0;
-  for (; await O(s); )
-    if (await b(100), e += 100, e > r)
+  for (; await k(s); )
+    if (await F(100), e += 100, e > r)
       throw new Error(`The process did not stopped after ${r} ms.`);
 }
-const dt = ["linux", "macos", "windows"];
-function k(s) {
+const ut = ["linux", "macos", "windows"];
+function O(s) {
   switch (s.toLowerCase()) {
     case "darwin":
       return "macos";
@@ -50,11 +50,11 @@ function k(s) {
       return "windows";
     default:
       throw new Error(
-        `operating system '${s}' is not currently supported by Platforma ecosystem. The list of OSes supported: ` + JSON.stringify(dt)
+        `operating system '${s}' is not currently supported by Platforma ecosystem. The list of OSes supported: ` + JSON.stringify(ut)
       );
   }
 }
-const ut = ["amd64", "arm64"];
+const wt = ["amd64", "arm64"];
 function S(s) {
   switch (s) {
     case "aarch64":
@@ -66,33 +66,33 @@ function S(s) {
       return "amd64";
     default:
       throw new Error(
-        `processor architecture '${s}' is not currently supported by Platforma ecosystem. The list of architectures supported: ` + JSON.stringify(ut)
+        `processor architecture '${s}' is not currently supported by Platforma ecosystem. The list of architectures supported: ` + JSON.stringify(wt)
       );
   }
 }
-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 = G(t, e, r, S(i), k(o)), { archiveUrl: c, alternativeArchiveGAUrl: a, archivePath: l } = n;
+const ft = "https://cdn.platforma.bio/software", pt = "https://cdn-ga.pl-open.science/software";
+async function mt(s, r, t, e, i, o) {
+  const n = L(t, e, r, S(i), O(o)), { archiveUrl: a, alternativeArchiveGAUrl: c, archivePath: l } = n;
   try {
-    await C(s, c, l), n.wasDownloadedFrom = c;
-  } catch {
     await C(s, a, l), n.wasDownloadedFrom = a;
+  } catch {
+    await C(s, c, l), n.wasDownloadedFrom = c;
   }
   return n;
 }
-async function mt(s, r, t, e, i, o) {
-  const n = G(t, e, r, S(i), k(o)), { archiveUrl: c, alternativeArchiveGAUrl: a, archivePath: l, archiveType: h, targetFolder: u, baseName: $ } = n;
+async function gt(s, r, t, e, i, o) {
+  const n = L(t, e, r, S(i), O(o)), { archiveUrl: a, alternativeArchiveGAUrl: c, archivePath: l, archiveType: h, targetFolder: u, baseName: $ } = n;
   try {
-    await C(s, c, l), n.wasDownloadedFrom = c;
-  } catch {
     await C(s, a, l), n.wasDownloadedFrom = a;
+  } catch {
+    await C(s, c, l), n.wasDownloadedFrom = c;
   }
-  return await yt(s, l, h, u), n;
+  return await $t(s, l, h, u), n;
 }
-function G(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);
+function L(s, r, t, e, i) {
+  const o = `${r}-${e}`, n = vt[i], a = `${o}.${n}`, c = `${ft}/${s}/${i}/${a}`, l = `${pt}/${s}/${i}/${a}`, h = d.join(t, a), u = d.join(t, o);
   return {
-    archiveUrl: a,
+    archiveUrl: c,
     alternativeArchiveGAUrl: l,
     archivePath: h,
     archiveType: n,
@@ -109,24 +109,24 @@ async function C(s, r, t) {
     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);
+    const { body: i, statusCode: o } = await et(r);
     if (e.statusCode = o, o != 200) {
-      const n = await ot(i);
+      const n = await st(i);
       throw e.errorMsg = `failed to download archive: ${o}, response: ${n.slice(0, 1e3)}`, s.error(e.errorMsg), new Error(e.errorMsg);
     }
-    return e.tmpPath = t + ".tmp", await et.toWeb(i).pipeTo(it.toWeb(D.createWriteStream(e.tmpPath))), e.wroteTmp = !0, e.tmpExisted = await y(e.tmpPath), await m.rename(e.tmpPath, t), e.renamed = !0, e.newExisted = await y(t), e;
+    return e.tmpPath = t + ".tmp", await it.toWeb(i).pipeTo(ot.toWeb(D.createWriteStream(e.tmpPath))), e.wroteTmp = !0, e.tmpExisted = await y(e.tmpPath), await m.rename(e.tmpPath, t), e.renamed = !0, e.newExisted = await y(t), e;
   } catch (i) {
-    const o = `downloadArchive: error ${JSON.stringify(i)} occurred, state: ${JSON.stringify(e)}`;
+    const o = `downloadArchive: ${JSON.stringify(i)}, state: ${JSON.stringify(e)}`;
     throw s.error(o), new Error(o);
   }
 }
-const gt = ".ok";
-async function yt(s, r, t, e) {
+const yt = ".ok";
+async function $t(s, r, t, e) {
   if (s.info("extracting archive..."), s.info(`  archive path: '${r}'`), s.info(`  target dir: '${e}'`), !await y(r)) {
     const o = `Platforma Backend binary archive not found at '${r}'`;
     throw s.error(o), new Error(o);
   }
-  const i = d.join(e, gt);
+  const i = d.join(e, yt);
   if (await y(i)) {
     s.info(`Platforma Backend binaries unpack skipped: '${e}' exists`);
     return;
@@ -137,21 +137,21 @@ async function yt(s, r, t, e) {
   Target dir: ${e}`
   ), t) {
     case "tgz":
-      await st.x({
+      await nt.x({
         file: r,
         cwd: e,
         gzip: !0
       });
       break;
     case "zip":
-      await nt(r, e);
+      await at(r, e);
       break;
     default:
-      j(t);
+      H(t);
   }
   await m.writeFile(i, "ok"), s.info("  ... unpack done.");
 }
-const $t = {
+const vt = {
   linux: "tgz",
   macos: "tgz",
   windows: "zip"
@@ -159,65 +159,65 @@ const $t = {
 function R() {
   return "1.24.0";
 }
-function vt() {
+function Pt() {
   return { type: "Download", version: R() };
 }
-async function Pt(s, r, t) {
+async function St(s, r, t) {
   switch (t.type) {
     case "Download":
-      const e = await mt(s, r, "pl", `pl-${t.version}`, A.arch(), A.platform());
-      return d.join(e.baseName, "binaries", St[k(A.platform())]);
+      const e = await gt(s, r, "pl", `pl-${t.version}`, A.arch(), A.platform());
+      return d.join(e.baseName, "binaries", Ct[O(A.platform())]);
     case "Local":
       return t.path;
     default:
-      j(t);
+      H(t);
   }
 }
-const St = {
+const Ct = {
   linux: "platforma",
   macos: "platforma",
   windows: "platforma.exe"
 };
-function L(s) {
+function V(s) {
   return d.join(s, "pl_pid");
 }
-async function Ct(s) {
+async function Et(s) {
   if (!await y(s))
     return;
   const r = await m.readFile(s);
   return Number(r.toString());
 }
-async function Et(s, r) {
+async function At(s, r) {
   await m.writeFile(s, JSON.stringify(r));
 }
-function At() {
+function bt() {
   return {};
 }
 function Ft(s, r, t) {
   return s[r] = t, t;
 }
 async function N(s, r) {
-  const t = At();
+  const t = bt();
   try {
     return await r((i, o) => Ft(t, i, o), t);
   } catch (e) {
     throw s.error(`error ${e} while doing traced operation, state: ${JSON.stringify(t)}`), e;
   }
 }
-const bt = "config-local.yaml";
-class Dt {
-  constructor(r, t, e, i, o, n, c, a) {
+const Dt = "config-local.yaml";
+class xt {
+  constructor(r, t, e, i, o, n, a, c) {
     w(this, "instance");
     w(this, "pid");
     w(this, "nRuns", 0);
     w(this, "lastRunHistory", {});
     w(this, "wasStopped", !1);
-    this.logger = r, this.workingDir = t, this.startOptions = e, this.initialStartHistory = i, this.onClose = o, this.onError = n, this.onCloseAndError = c, this.onCloseAndErrorNoStop = a;
+    this.logger = r, this.workingDir = t, this.startOptions = e, this.initialStartHistory = i, this.onClose = o, this.onError = n, this.onCloseAndError = a, this.onCloseAndErrorNoStop = c;
   }
   async start() {
     await N(this.logger, async (r, t) => {
       this.wasStopped = !1;
-      const e = ht(this.logger, this.startOptions);
+      const e = dt(this.logger, this.startOptions);
       e.on("error", (o) => {
         this.logger.error(
           `error '${o}', while running platforma, started opts: ${JSON.stringify(this.debugInfo())}`
@@ -225,21 +225,21 @@ class Dt {
       }), 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", L(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;
+      const i = r("pidFile", V(this.workingDir));
+      r("pid", f(e.pid)), r("pidWritten", await At(i, f(e.pid))), this.nRuns++, this.instance = e, this.pid = e.pid, this.lastRunHistory = t;
     });
   }
   stop() {
-    this.wasStopped = !0, J(f(this.pid));
+    this.wasStopped = !0, G(f(this.pid));
   }
   async waitStopped() {
-    await M(f(this.pid), 15e3);
+    await J(f(this.pid), 15e3);
   }
   stopped() {
     return this.wasStopped;
   }
   async isAlive() {
-    return await O(f(this.pid));
+    return await k(f(this.pid));
   }
   debugInfo() {
     return {
@@ -252,9 +252,9 @@ class Dt {
     };
   }
 }
-async function fr(s, r) {
+async function gr(s, r) {
   const t = {
-    plBinary: vt(),
+    plBinary: Pt(),
     spawnOptions: {},
     closeOld: !0,
     ...r
@@ -262,11 +262,11 @@ async function fr(s, r) {
   return await N(s, async (e, i) => {
     e("startOptions", { ...t, config: "too wordy" });
     const o = d.resolve(t.workingDir);
-    t.closeOld && e("closeOld", await xt(s, o));
-    const n = d.join(o, bt);
+    t.closeOld && e("closeOld", await kt(s, o));
+    const n = d.join(o, Dt);
     s.info(`writing configuration '${n}'...`), await m.writeFile(n, t.config);
-    const c = d.join(o, "binaries"), a = await Pt(s, c, t.plBinary), h = {
-      cmd: e("binaryPath", d.join("binaries", a)),
+    const a = d.join(o, "binaries"), c = await St(s, a, t.plBinary), h = {
+      cmd: e("binaryPath", d.join("binaries", c)),
       args: ["--config", n],
       opts: {
         env: { ...process.env },
@@ -282,7 +282,7 @@ async function fr(s, r) {
       args: h.args,
       cwd: h.opts.cwd
     });
-    const u = new Dt(
+    const u = new xt(
       s,
       t.workingDir,
       h,
@@ -295,10 +295,10 @@ async function fr(s, r) {
     return await u.start(), u;
   });
 }
-async function xt(s, r) {
+async function kt(s, r) {
   return await N(s, async (t, e) => {
-    const i = t("pidFilePath", L(r)), o = t("pid", await Ct(i)), n = t("wasAlive", await O(o));
-    return o !== void 0 && n && (t("stopped", J(o)), t("waitStopped", await M(o, 1e4))), e;
+    const i = t("pidFilePath", V(r)), o = t("pid", await Et(i)), n = t("wasAlive", await k(o));
+    return o !== void 0 && n && (t("stopped", G(o)), t("waitStopped", await J(o, 1e4))), e;
   });
 }
 const Ot = {
@@ -321,7 +321,7 @@ class B {
     const e = {
       ...Ot,
       ...t
-    }, i = new B(r, new F());
+    }, i = new B(r, new b());
     return await i.connect(e), i;
   }
   getForwardedServers() {
@@ -341,7 +341,7 @@ class B {
    * @returns A promise that resolves when the connection is established or rejects on error.
    */
   async connect(r) {
-    return this.config = r, await kt(this.client, r);
+    return this.config = r, await Rt(this.client, r);
   }
   /**
    * Executes a command on the SSH server.
@@ -352,14 +352,14 @@ class B {
     return new Promise((t, e) => {
       this.client.exec(r, (i, o) => {
         if (i)
-          return e(`ssh.exec: ${r}, error occurred: ${i}`);
-        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();
+          return e(`ssh.exec: ${r}: ${i}`);
+        let n = "", a = "";
+        o.on("close", (c) => {
+          c === 0 ? t({ stdout: n, stderr: a }) : e(new Error(`Command ${r} exited with code ${c}, stdout: ${n}, stderr: ${a}`));
+        }).on("data", (c) => {
+          n += c.toString();
+        }).stderr.on("data", (c) => {
+          a += c.toString();
         });
       });
     });
@@ -373,7 +373,7 @@ class B {
   static async getAuthTypes(r, t) {
     return new Promise((e) => {
       let i = "";
-      const o = new F();
+      const o = new b();
       o.on("ready", () => {
         o.end();
         const n = this.extractAuthMethods(i);
@@ -410,48 +410,48 @@ class B {
   async forwardPort(r, t) {
     const e = `ssh.forward:${r.localPort}:${r.remotePort}.id_${x(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", () => {
+    const i = new tt((o) => new Promise((n, a) => {
+      const c = new b();
+      c.on("ready", () => {
+        this.logger.info(`${e}.client.ready`), n(c);
+      }), c.on("error", (l) => {
+        this.logger.info(`${e}.client.error: ${l}`), o.reset(), a(l);
+      }), c.on("close", () => {
         this.logger.info(`${e}.client.closed`), o.reset();
-      }), a.connect(t);
+      }), c.connect(t);
     }));
     return await i.ensure(), new Promise((o, n) => {
-      const c = H.createServer({ pauseOnConnect: !0 }, async (a) => {
+      const a = M.createServer({ pauseOnConnect: !0 }, async (c) => {
         const l = `${e}.sock_${x(1).toString("hex")}`;
         let h;
         try {
           h = await i.ensure();
         } catch ($) {
-          this.logger.info(`${l}.persistentClient.catch: ${$}`), a.end();
+          this.logger.info(`${l}.persistentClient.catch: ${$}`), c.end();
           return;
         }
-        h.setNoDelay(!0), a.setNoDelay(!0);
+        h.setNoDelay(!0), c.setNoDelay(!0);
         let u;
         try {
-          u = await Rt(this.logger, h, "127.0.0.1", 0, "127.0.0.1", r.remotePort);
+          u = await Nt(this.logger, h, "127.0.0.1", 0, "127.0.0.1", r.remotePort);
         } catch ($) {
-          this.logger.error(`${l}.forwardOut.err: ${$}`), a.end();
+          this.logger.error(`${l}.forwardOut.err: ${$}`), c.end();
           return;
         }
-        a.pipe(u), u.pipe(a), a.resume(), u.on("error", ($) => {
-          this.logger.error(`${l}.stream.error: ${$}`), a.end(), u.end();
+        c.pipe(u), u.pipe(c), c.resume(), u.on("error", ($) => {
+          this.logger.error(`${l}.stream.error: ${$}`), c.end(), u.end();
         }), u.on("close", () => {
-          a.end(), u.end();
-        }), a.on("close", () => {
-          this.logger.info(`${l}.localSocket: closed`), a.end(), u.end();
+          c.end(), u.end();
+        }), c.on("close", () => {
+          this.logger.info(`${l}.localSocket: closed`), c.end(), u.end();
         });
       });
-      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(r)}`), this.forwardedServers = this.forwardedServers.filter((a) => a !== c);
+      a.listen(r.localPort, "127.0.0.1", () => {
+        this.logger.info(`${e}.server: started listening`), this.forwardedServers.push(a), o({ server: a });
+      }), a.on("error", (c) => {
+        a.close(), n(new Error(`${e}.server: error: ${JSON.stringify(c)}`));
+      }), a.on("close", () => {
+        this.logger.info(`${e}.server: closed ${JSON.stringify(r)}`), this.forwardedServers = this.forwardedServers.filter((c) => c !== a);
       });
     });
   }
@@ -472,7 +472,7 @@ class B {
   */
   static async checkHostAvailability(r) {
     return new Promise((t) => {
-      ct.lookup(r, (e) => {
+      lt.lookup(r, (e) => {
         t(!e);
       });
     });
@@ -485,7 +485,7 @@ class B {
   static async isPassphraseRequiredForKey(r) {
     return new Promise((t, e) => {
       try {
-        return at.utils.parseKey(r) instanceof Error && t(!0), t(!1);
+        return ct.utils.parseKey(r) instanceof Error && t(!0), t(!1);
       } catch (i) {
         console.log("Error parsing privateKey"), e(new Error(`ssh.isPassphraseRequiredForKey: err ${i}`));
       }
@@ -502,10 +502,10 @@ class B {
     return await this.withSftp(async (e) => new Promise((i, o) => {
       e.fastPut(r, t, (n) => {
         if (n) {
-          const c = new Error(
+          const a = new Error(
             `ssh.uploadFile: err: ${n}, localPath: ${r}, remotePath: ${t}`
           );
-          return o(c);
+          return o(a);
         }
         i(!0);
       });
@@ -529,12 +529,12 @@ class B {
   }
   async getForderStructure(r, t, e = { files: [], directories: [] }) {
     return new Promise((i, o) => {
-      r.readdir(t, async (n, c) => {
+      r.readdir(t, async (n, a) => {
         if (n)
           return o(n);
-        for (const a of c) {
-          const l = `${t}/${a.filename}`;
-          if (a.attrs.isDirectory()) {
+        for (const c of a) {
+          const l = `${t}/${c.filename}`;
+          if (c.attrs.isDirectory()) {
             e.directories.push(l);
             try {
               await this.getForderStructure(r, l, e);
@@ -580,7 +580,7 @@ class B {
     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}`));
+          return i(new Error(`ssh.readFile: ${o}`));
         e(n.toString());
       });
     }));
@@ -614,20 +614,20 @@ class B {
   }
   async writeFile(r, t, e, i = 432) {
     return new Promise((o, n) => {
-      r.writeFile(t, e, { mode: i }, (c) => {
-        if (c)
-          return n(new Error(`ssh.writeFile: err ${c}, remotePath: ${t}`));
+      r.writeFile(t, e, { mode: i }, (a) => {
+        if (a)
+          return n(new Error(`ssh.writeFile: err ${a}, remotePath: ${t}`));
         o(!0);
       });
     });
   }
   uploadFileUsingExistingSftp(r, t, e, i = 432) {
     return new Promise((o, n) => {
-      tt(t).then(async (c) => {
-        this.writeFile(r, e, c, i).then(() => {
+      rt(t).then(async (a) => {
+        this.writeFile(r, e, a, i).then(() => {
           o(void 0);
-        }).catch((a) => {
-          const l = `uploadFileUsingExistingSftp: error ${a} occurred`;
+        }).catch((c) => {
+          const l = `uploadFileUsingExistingSftp: ${c}`;
           this.logger.error(l), n(new Error(l));
         });
       });
@@ -635,12 +635,12 @@ class B {
   }
   async __uploadDirectory(r, t, e, i = 432) {
     return new Promise((o, n) => {
-      D.readdir(t, async (c, a) => {
-        if (c)
-          return n(new Error(`ssh.__uploadDir: err ${c}, localDir: ${t}, remoteDir: ${e}`));
+      D.readdir(t, async (a, c) => {
+        if (a)
+          return n(new Error(`ssh.__uploadDir: err ${a}, localDir: ${t}, remoteDir: ${e}`));
         try {
           await this.__createRemoteDirectory(r, e);
-          for (const l of a) {
+          for (const l of c) {
             const h = d.join(t, l), u = `${e}/${l}`;
             D.lstatSync(h).isDirectory() ? await this.__uploadDirectory(r, h, u, i) : await this.uploadFileUsingExistingSftp(r, h, u, i);
           }
@@ -663,8 +663,8 @@ class B {
       this.withSftp(async (n) => {
         try {
           await this.__uploadDirectory(n, r, t, e), i();
-        } catch (c) {
-          o(new Error(`ssh.uploadDirectory: ${c}`));
+        } catch (a) {
+          o(new Error(`ssh.uploadDirectory: ${a}`));
         }
       });
     });
@@ -679,18 +679,18 @@ class B {
     return new Promise((e, i) => {
       const o = t.split("/");
       let n = "";
-      const c = (a) => {
-        if (a >= o.length)
+      const a = (c) => {
+        if (c >= o.length)
           return e();
-        n += `${o[a]}/`, r.stat(n, (l) => {
+        n += `${o[c]}/`, r.stat(n, (l) => {
           l ? r.mkdir(n, (h) => {
             if (h)
               return i(new Error(`ssh.__createRemDir: err ${h}, remotePath: ${t}`));
-            c(a + 1);
-          }) : c(a + 1);
+            a(c + 1);
+          }) : a(c + 1);
         });
       };
-      c(0);
+      a(0);
     });
   }
   /**
@@ -706,18 +706,18 @@ class B {
       for (const n of i) {
         o += `${n}/`;
         try {
-          await new Promise((c, a) => {
+          await new Promise((a, c) => {
             e.stat(o, (l) => {
-              if (!l) return c();
+              if (!l) return a();
               e.mkdir(o, { mode: t }, (h) => {
                 if (h)
-                  return a(new Error(`ssh.createRemoteDir: err ${h}, remotePath: ${r}`));
-                c();
+                  return c(new Error(`ssh.createRemoteDir: err ${h}, remotePath: ${r}`));
+                a();
               });
             });
           });
-        } catch (c) {
-          throw console.error(`Failed to create directory: ${o}`, c), c;
+        } catch (a) {
+          throw console.error(`Failed to create directory: ${o}`, a), a;
         }
       }
     });
@@ -744,87 +744,87 @@ class B {
     this.closeForwardedPorts(), this.client.end();
   }
 }
-async function kt(s, r, t, e) {
+async function Rt(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}`));
+      o(new Error(`ssh.connect: ${n}`));
     }), s.on("close", () => {
     }), s.connect(r), s.setNoDelay(!0);
   });
 }
-async function Rt(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));
+async function Nt(s, r, t, e, i, o) {
+  return new Promise((n, a) => {
+    r.forwardOut(t, e, i, o, (c, l) => c ? (s.error(`forwardOut.error: ${c}`), a(c)) : n(l));
   });
 }
-const Nt = "minio-2024-12-18T13-15-44Z", Bt = "supervisord-0.7.3", Ut = "supervisord_0.7.3_Linux_64-bit";
+const Bt = "minio-2024-12-18T13-15-44Z", Ut = "supervisord-0.7.3", Tt = "supervisord_0.7.3_Linux_64-bit";
 function g(s) {
   return d.join(s, ".platforma_ssh");
 }
 function E(s) {
   return d.join(g(s), "binaries");
 }
-function Tt(s, r) {
+function It(s, r) {
   return d.join(E(s), `pl-${R()}-${S(r)}`);
 }
 function W(s, r) {
-  return d.join(Tt(s, r), "binaries");
+  return d.join(It(s, r), "binaries");
 }
 function T(s, r) {
   return d.join(W(s, r), "platforma");
 }
-function It(s, r) {
+function _t(s, r) {
   return d.join(W(s, r), "free-port");
 }
 function z(s, r) {
   return d.join(E(s), `minio-2024-12-18T13-15-44Z-${S(r)}`);
 }
-function _t(s, r) {
+function jt(s, r) {
   return d.join(z(s, r), "minio");
 }
-function jt(s, r) {
-  return d.join(E(s), `supervisord-0.7.3-${S(r)}`, Ut);
+function Ht(s, r) {
+  return d.join(E(s), `supervisord-0.7.3-${S(r)}`, Tt);
 }
-function K(s, r) {
-  return d.join(jt(s, r), "supervisord");
+function q(s, r) {
+  return d.join(Ht(s, r), "supervisord");
 }
-function V(s) {
+function K(s) {
   return d.join(g(s), "supervisor.conf");
 }
 function I(s) {
   return d.join(g(s), "connection.txt");
 }
-async function Ht(s, r, t) {
+async function Mt(s, r, t) {
   const e = await U(s, r, t, "--daemon");
   if (e.stderr)
     throw new Error(`Can not run ssh Platforma ${e.stderr}`);
 }
-async function Jt(s, r, t) {
+async function Gt(s, r, t) {
   const e = await U(s, r, t, "ctl shutdown");
   if (e.stderr)
     throw new Error(`Can not stop ssh Platforma ${e.stderr}`);
 }
-async function Mt(s, r, t, e) {
+async function Jt(s, r, t, e) {
   let i;
   try {
     i = await U(r, t, e, "ctl status");
-  } catch (a) {
-    return { execError: String(a), allAlive: !1 };
+  } catch (c) {
+    return { execError: String(c), allAlive: !1 };
   }
   if (i.stderr)
     return s.info(`supervisord ctl status: stderr occurred: ${i.stderr}, stdout: ${i.stdout}`), { rawResult: i, allAlive: !1 };
-  const o = _(i.stdout, "platforma"), n = _(i.stdout, "minio"), c = {
+  const o = _(i.stdout, "platforma"), n = _(i.stdout, "minio"), a = {
     rawResult: i,
     platforma: o,
     minio: n,
     allAlive: o && n
   };
-  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;
+  return a.allAlive || (a.minio || s.warn("Minio is not running on the server"), a.platforma || s.warn("Platforma is not running on the server")), a;
 }
-function Gt(s, r, t, e, i, o, n) {
-  const c = Object.entries(r).map(([h, u]) => `${h}="${u}"`).join(","), a = x(16).toString("hex"), l = t;
+function Lt(s, r, t, e, i, o, n) {
+  const a = Object.entries(r).map(([h, u]) => `${h}="${u}"`).join(","), c = x(16).toString("hex"), l = t;
   return `
 [supervisord]
 logfile=${e}/supervisord.log
@@ -834,12 +834,12 @@ pidfile=${e}/supervisord.pid
 [inet_http_server]
 port=127.0.0.1:${l}
 username=default-user
-password=${a}
+password=${c}
 
 [supervisorctl]
 serverurl=http://127.0.0.1:${l}
 username=default-user
-password=${a}
+password=${c}
 
 [program:platforma]
 autostart=true
@@ -850,14 +850,14 @@ autorestart=true
 
 [program:minio]
 autostart=true
-environment=${c}
+environment=${a}
 command=${o} server ${s}
 directory=${e}
 autorestart=true
 `;
 }
 async function U(s, r, t, e) {
-  const i = K(r, t), o = V(r), n = `${i} --configuration ${o} ${e}`;
+  const i = q(r, t), o = K(r), n = `${i} --configuration ${o} ${e}`;
   return await s.exec(n);
 }
 function _(s, r) {
@@ -870,7 +870,7 @@ function _(s, r) {
 const P = p.object({
   local: p.number(),
   remote: p.number()
-}), Lt = p.object({
+}), Vt = p.object({
   grpc: P,
   monitoring: P,
   debug: P,
@@ -879,7 +879,7 @@ const P = p.object({
 }), Wt = p.object({
   plUser: p.string(),
   plPassword: p.string(),
-  ports: Lt,
+  ports: Vt,
   // 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),
@@ -895,13 +895,14 @@ function zt(s, r, t, e, i) {
     plVersion: i
   };
 }
-function Kt(s) {
+function qt(s) {
   return Wt.parse(JSON.parse(s));
 }
-function Vt(s) {
+function Kt(s) {
   return JSON.stringify(s, void 0, 2);
 }
-class q {
+const j = 2.28;
+class Z {
   constructor(r, t, e) {
     w(this, "initState", {});
     this.logger = r, this.sshClient = t, this.username = e;
@@ -915,7 +916,7 @@ class q {
   static async init(r, t) {
     try {
       const e = await B.init(r, t);
-      return new q(r, e, f(t.username));
+      return new Z(r, e, f(t.username));
     } catch (e) {
       throw r.error(`Connection error in SshClient.init: ${e}`), e;
     }
@@ -926,7 +927,7 @@ class q {
   /** Provides an info if the platforma and minio are running along with the debug info. */
   async isAlive() {
     const r = await this.getArch(), t = await this.getUserHomeDirectory();
-    return await Mt(this.logger, this.sshClient, t, r.arch);
+    return await Jt(this.logger, this.sshClient, t, r.arch);
   }
   /** Starts all the services on the server.
     * Idempotent semantic: we could call it several times. */
@@ -934,9 +935,9 @@ class q {
     const r = await this.getArch(), t = await this.getUserHomeDirectory();
     try {
       if (!(await this.isAlive()).allAlive)
-        return await Ht(this.sshClient, t, r.arch), await this.checkIsAliveWithInterval();
+        return await Mt(this.sshClient, t, r.arch), await this.checkIsAliveWithInterval();
     } catch (e) {
-      const i = `SshPl.start: error occurred ${e}`;
+      const i = `SshPl.start: ${e}`;
       throw this.logger.error(i), new Error(i);
     }
   }
@@ -946,9 +947,9 @@ class q {
     const r = await this.getArch(), t = await this.getUserHomeDirectory();
     try {
       if ((await this.isAlive()).allAlive)
-        return await Jt(this.sshClient, t, r.arch), await this.checkIsAliveWithInterval(void 0, void 0, !1);
+        return await Gt(this.sshClient, t, r.arch), await this.checkIsAliveWithInterval(void 0, void 0, !1);
     } catch (e) {
-      const i = `PlSsh.stop: error occurred ${e}`;
+      const i = `PlSsh.stop: ${e}`;
       throw this.logger.error(i), new Error(i);
     }
   }
@@ -968,26 +969,29 @@ class q {
     const t = { localWorkdir: r.localWorkdir };
     try {
       const e = {
-        ...qt,
+        ...Zt,
         ...r
       };
       if (t.plBinaryOps = e.plBinary, t.arch = await this.getArch(), t.remoteHome = await this.getUserHomeDirectory(), t.alive = await this.isAlive(), t.alive.allAlive) {
         if (t.userCredentials = await this.getUserCredentials(t.remoteHome), !t.userCredentials)
           throw new Error("SshPl.platformaInit: platforma is alive but userCredentials are not found");
-        const a = t.userCredentials.useGlobalAccess == e.useGlobalAccess, l = t.userCredentials.plVersion == e.plBinary.version;
-        if (t.needRestart = !(a && l), this.logger.info(`SshPl.platformaInit: need restart? ${t.needRestart}`), !t.needRestart)
+        const l = t.userCredentials.useGlobalAccess == e.useGlobalAccess, h = t.userCredentials.plVersion == e.plBinary.version;
+        if (t.needRestart = !(l && h), this.logger.info(`SshPl.platformaInit: need restart? ${t.needRestart}`), !t.needRestart)
           return t.userCredentials;
         await this.stop();
       }
-      const i = await this.downloadBinariesAndUploadToTheServer(
+      const i = await Yt(this.logger, this.sshClient);
+      if (i < j)
+        throw new Error(`glibc version ${i} is too old. Version ${j} or higher is required for Platforma.`);
+      const o = await this.downloadBinariesAndUploadToTheServer(
         e.localWorkdir,
         e.plBinary,
         t.remoteHome,
         t.arch
       );
-      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)
+      if (t.binPaths = { ...o, history: void 0 }, t.downloadedBinaries = o.history, t.ports = await this.fetchPorts(t.remoteHome, t.arch), !t.ports.debug.remote || !t.ports.grpc.remote || !t.ports.minioPort.remote || !t.ports.minioConsolePort.remote || !t.ports.monitoring.remote)
         throw new Error("SshPl.platformaInit: remote ports are not defined");
-      const o = await lt({
+      const n = await ht({
         logger: this.logger,
         workingDir: g(t.remoteHome),
         portsMode: {
@@ -1003,36 +1007,37 @@ class q {
           }
         },
         licenseMode: e.license,
-        useGlobalAccess: f(e.useGlobalAccess)
+        useGlobalAccess: f(e.useGlobalAccess),
+        plConfigPostprocessing: e.plConfigPostprocessing
       });
-      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.ensureRemoteDirCreated(a), this.logger.info(`Created directory ${a}`);
-      const n = Gt(
-        o.minioConfig.storageDir,
-        o.minioConfig.envs,
+      t.generatedConfig = { ...n, filesToCreate: { skipped: "it is too wordy" } };
+      for (const [l, h] of Object.entries(n.filesToCreate))
+        await this.sshClient.writeFileOnTheServer(l, h), this.logger.info(`Created file ${l}`);
+      for (const l of n.dirsToCreate)
+        await this.sshClient.ensureRemoteDirCreated(l), this.logger.info(`Created directory ${l}`);
+      const a = Lt(
+        n.minioConfig.storageDir,
+        n.minioConfig.envs,
         await this.getFreePortForPlatformaOnServer(t.remoteHome, t.arch),
-        o.workingDir,
-        o.plConfig.configPath,
+        n.workingDir,
+        n.plConfig.configPath,
         t.binPaths.minioRelPath,
         t.binPaths.downloadedPl
       );
-      if (!await this.sshClient.writeFileOnTheServer(V(t.remoteHome), n))
+      if (!await this.sshClient.writeFileOnTheServer(K(t.remoteHome), a))
         throw new Error(`Can not write supervisord config on the server ${g(t.remoteHome)}`);
       return t.connectionInfo = zt(
-        o.plUser,
-        o.plPassword,
+        n.plUser,
+        n.plPassword,
         t.ports,
         f(e.useGlobalAccess),
         e.plBinary.version
       ), await this.sshClient.writeFileOnTheServer(
         I(t.remoteHome),
-        Vt(t.connectionInfo)
+        Kt(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(t)}`;
+      const i = `SshPl.platformaInit: ${e}, state: ${JSON.stringify(t)}`;
       throw this.logger.error(i), new Error(i);
     }
   }
@@ -1047,29 +1052,29 @@ class q {
         `pl-${t.version}`
       );
       o.push(n);
-      const c = await this.downloadAndUntar(
+      const a = await this.downloadAndUntar(
         r,
         e,
         i,
         "supervisord",
-        Bt
+        Ut
       );
-      o.push(c);
-      const a = _t(e, i.arch), l = await this.downloadAndUntar(
+      o.push(a);
+      const c = jt(e, i.arch), l = await this.downloadAndUntar(
         r,
         e,
         i,
         "minio",
-        Nt
+        Bt
       );
-      return o.push(l), await this.sshClient.chmod(a, 488), {
+      return o.push(l), await this.sshClient.chmod(c, 488), {
         history: o,
-        minioRelPath: a,
+        minioRelPath: c,
         downloadedPl: T(e, i.arch)
       };
     } catch (n) {
-      const c = `SshPl.downloadBinariesAndUploadToServer: error ${n} occurred, state: ${JSON.stringify(o)}`;
-      throw this.logger.error(c), n;
+      const a = `SshPl.downloadBinariesAndUploadToServer: ${n}, state: ${JSON.stringify(o)}`;
+      throw this.logger.error(a), n;
     }
   }
   /** We have to extract pl in the remote server,
@@ -1081,11 +1086,11 @@ class q {
   async downloadAndUntar(r, t, e, i, o) {
     const n = {};
     n.binBasePath = E(t), await this.sshClient.ensureRemoteDirCreated(n.binBasePath), n.binBasePathCreated = !0;
-    let c = null;
-    const a = 5;
-    for (let h = 1; h <= a; h++)
+    let a = null;
+    const c = 5;
+    for (let h = 1; h <= c; h++)
       try {
-        c = await pt(
+        a = await mt(
           this.logger,
           r,
           i,
@@ -1095,33 +1100,38 @@ class q {
         );
         break;
       } catch (u) {
-        if (await b(300), h == a)
-          throw new Error(`downloadAndUntar: ${a} attempts, last error: ${u}`);
+        if (await F(300), h == c)
+          throw new Error(`downloadAndUntar: ${c} attempts, last error: ${u}`);
       }
-    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.ensureRemoteDirCreated(n.remoteDir), await this.sshClient.uploadFile(n.localArchivePath, n.remoteArchivePath), n.uploadDone = !0;
+    n.downloadResult = f(a), n.localArchivePath = d.resolve(n.downloadResult.archivePath), n.remoteDir = d.join(n.binBasePath, n.downloadResult.baseName), n.remoteArchivePath = n.remoteDir + ".tgz", await this.sshClient.ensureRemoteDirCreated(n.remoteDir), await this.sshClient.uploadFile(n.localArchivePath, n.remoteArchivePath), n.uploadDone = !0;
+    try {
+      await this.sshClient.exec("hash tar");
+    } catch {
+      throw new Error("tar is not installed on the server. Please install it before running Platforma.");
+    }
     const l = await this.sshClient.exec(
       `tar --warning=no-all -xvf ${n.remoteArchivePath} --directory=${n.remoteDir}`
     );
     if (l.stderr)
-      throw Error(`downloadAndUntar: untar: stderr occurred: ${l.stderr}, stdout: ${l.stdout}`);
+      throw new Error(`downloadAndUntar: untar: stderr occurred: ${l.stderr}, stdout: ${l.stdout}`);
     return n.untarDone = !0, n;
   }
   async needDownload(r, t) {
-    const e = K(r, t.arch), i = z(r, t.arch), o = T(r, t.arch);
+    const e = q(r, t.arch), i = z(r, t.arch), o = T(r, t.arch);
     return !await this.sshClient.checkFileExists(o) || !await this.sshClient.checkFileExists(i) || !await this.sshClient.checkFileExists(e);
   }
   async checkIsAliveWithInterval(r = 1e3, t = 15, e = !0) {
     const i = t * r;
     let o = 0, n = await this.isAlive();
     for (; e ? !n.allAlive : n.allAlive; ) {
-      if (await b(r), o += r, o > i)
+      if (await F(r), o += r, o > i)
         throw new Error(`isAliveWithInterval: The process did not ${e ? "started" : "stopped"} after ${i} ms. Live status: ${JSON.stringify(n)}`);
       n = await this.isAlive();
     }
   }
   async getUserCredentials(r) {
     const t = await this.sshClient.readFile(I(r));
-    return Kt(t);
+    return qt(t);
   }
   async fetchPorts(r, t) {
     return {
@@ -1149,7 +1159,7 @@ class q {
   }
   async getLocalFreePort() {
     return new Promise((r) => {
-      const t = H.createServer();
+      const t = M.createServer();
       t.listen(0, () => {
         const e = t.address().port;
         t.close((i) => r(e));
@@ -1157,7 +1167,7 @@ class q {
     });
   }
   async getFreePortForPlatformaOnServer(r, t) {
-    const e = It(r, t.arch), { stdout: i, stderr: o } = await this.sshClient.exec(`${e}`);
+    const e = _t(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;
@@ -1182,25 +1192,42 @@ class q {
     return r.trim();
   }
 }
-const qt = {
+const Zt = {
   useGlobalAccess: !1,
   plBinary: {
     type: "Download",
     version: R()
   }
 };
+async function Yt(s, r) {
+  try {
+    const { stdout: t, stderr: e } = await r.exec("ldd --version | head -n 1");
+    if (e)
+      throw new Error(`Failed to check glibc version: ${e}`);
+    return Qt(t);
+  } catch (t) {
+    throw s.error(`glibc version check failed: ${t}`), t;
+  }
+}
+function Qt(s) {
+  const r = s.match(/\d+\.\d+/);
+  if (!r)
+    throw new Error(`Could not parse glibc version from: ${s}`);
+  return parseFloat(r[0]);
+}
 export {
   Wt as ConnectionInfo,
-  bt as LocalConfigYaml,
-  Dt as LocalPl,
+  Dt as LocalConfigYaml,
+  xt as LocalPl,
   P as PortPair,
   B as SshClient,
-  q as SshPl,
-  Lt as SshPlPorts,
+  Z as SshPl,
+  Vt as SshPlPorts,
   R as getDefaultPlVersion,
-  fr as localPlatformaInit,
+  gr as localPlatformaInit,
   zt as newConnectionInfo,
-  Kt as parseConnectionInfo,
-  Vt as stringifyConnectionInfo
+  qt as parseConnectionInfo,
+  Qt as parseGlibcVersion,
+  Kt as stringifyConnectionInfo
 };
 //# sourceMappingURL=index.mjs.map