@milaboratories/pl-deployments 1.1.2 → 1.1.4

package/dist/index.mjs

@@ -5,17 +5,17 @@ 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";
 import E from "node:fs";
 import w, { readFile as Z } from "node:fs/promises";
-import h from "upath";
+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 x from "node:os";
+import k from "node:os";
 import et, { Client as v } from "ssh2";
-import T from "node:net";
-import ot from "node:dns";
-import { generateSshPlConfigs as it, getFreePort as y } from "@milaboratories/pl-config";
+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) {
   return s.info(`Running:
@@ -29,7 +29,7 @@ async function C(s) {
     return !1;
   }
 }
-function U(s) {
+function T(s) {
   return process.kill(s, "SIGINT");
 }
 async function B(s, r) {
@@ -39,7 +39,7 @@ async function B(s, r) {
       throw new Error(`The process did not stopped after ${r} ms.`);
 }
 const at = ["linux", "macos", "windows"];
-function _(s) {
+function H(s) {
   switch (s.toLowerCase()) {
     case "darwin":
       return "macos";
@@ -54,7 +54,7 @@ function _(s) {
   }
 }
 const ct = ["amd64", "arm64"];
-function g(s) {
+function $(s) {
   switch (s) {
     case "aarch64":
     case "aarch64_be":
@@ -69,63 +69,63 @@ function g(s) {
       );
   }
 }
-async function lt(s, r, t, e, o, i) {
-  const n = ut(t, e, r, g(o), _(i)), { archiveUrl: a, archivePath: c } = n;
-  return await H(s, a, c), n;
+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 ht(s, r, t, e, o) {
-  const i = dt(t, r, g(e), _(o)), { archiveUrl: n, archivePath: a, archiveType: c, targetFolder: l, binaryPath: u } = i;
-  return await H(s, n, a), await pt(s, a, c, l), i;
+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;
 }
-function ut(s, r, t, e, o) {
-  const i = `${r}-${e}`, n = I[o], a = `${i}.${n}`, c = `https://cdn.platforma.bio/software/${s}/${o}/${a}`, l = h.join(t, a), u = h.join(t, i);
+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);
   return {
     archiveUrl: c,
     archivePath: l,
     archiveType: n,
-    targetFolder: u,
-    baseName: i
+    targetFolder: h,
+    baseName: o
   };
 }
 function dt(s, r, t, e) {
-  const o = `pl-${s}-${t}`, i = I[e], n = `${o}.${i}`, a = `https://cdn.platforma.bio/software/pl/${e}/${n}`, c = h.join(r, n), l = h.join(r, o), u = h.join(o, "binaries", ft[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]);
   return {
     archiveUrl: a,
     archivePath: c,
-    archiveType: i,
+    archiveType: o,
     targetFolder: l,
-    binaryPath: u,
-    baseName: o
+    binaryPath: h,
+    baseName: i
   };
 }
-async function H(s, r, t) {
+async function _(s, r, t) {
   const e = {};
   e.dstArchive = t;
   try {
     if (e.fileExisted = await f(t), e.fileExisted)
       return s.info(`Platforma Backend archive download skipped: '${t}' already exists`), e;
-    await w.mkdir(h.dirname(t), { recursive: !0 }), e.dirnameCreated = !0, s.info(`Downloading archive:
+    await w.mkdir(u.dirname(t), { recursive: !0 }), e.dirnameCreated = !0, s.info(`Downloading archive:
   URL: ${r}
  Save to: ${t}`);
-    const { body: o, statusCode: i } = await V(r);
-    if (e.statusCode = i, i != 200) {
-      const n = await X(o);
-      throw e.errorMsg = `failed to download archive: ${i}, response: ${n.slice(0, 1e3)}`, s.error(e.errorMsg), new Error(e.errorMsg);
+    const { body: i, statusCode: o } = await V(r);
+    if (e.statusCode = o, o != 200) {
+      const n = await X(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(o).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;
-  } catch (o) {
-    const i = `downloadArchive: error ${JSON.stringify(o)} occurred, state: ${JSON.stringify(e)}`;
-    throw s.error(i), new Error(i);
+    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;
+  } 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 i = `Platforma Backend binary archive not found at '${r}'`;
-    throw s.error(i), new Error(i);
+    const o = `Platforma Backend binary archive not found at '${r}'`;
+    throw s.error(o), new Error(o);
   }
-  const o = h.join(e, wt);
-  if (await f(o)) {
+  const i = u.join(e, wt);
+  if (await f(i)) {
     s.info(`Platforma Backend binaries unpack skipped: '${e}' exists`);
     return;
   }
@@ -147,7 +147,7 @@ async function pt(s, r, t, e) {
     default:
       N(t);
   }
-  await w.writeFile(o, "ok"), s.info("  ... unpack done.");
+  await w.writeFile(i, "ok"), s.info("  ... unpack done.");
 }
 const I = {
   linux: "tgz",
@@ -158,16 +158,16 @@ const I = {
   macos: "platforma",
   windows: "platforma.exe"
 };
-function b() {
+function F() {
   return "1.18.3";
 }
 function mt() {
-  return { type: "Download", version: b() };
+  return { type: "Download", version: F() };
 }
-async function yt(s, r, t) {
+async function gt(s, r, t) {
   switch (t.type) {
     case "Download":
-      return (await ht(s, r, t.version, x.arch(), x.platform())).binaryPath;
+      return (await ht(s, r, t.version, k.arch(), k.platform())).binaryPath;
     case "Local":
       return t.path;
     default:
@@ -175,9 +175,9 @@ async function yt(s, r, t) {
   }
 }
 function j(s) {
-  return h.join(s, "pl_pid");
+  return u.join(s, "pl_pid");
 }
-async function gt(s) {
+async function yt(s) {
   if (!await f(s))
     return;
   const r = await w.readFile(s);
@@ -192,41 +192,41 @@ function Pt() {
 function vt(s, r, t) {
   return s[r] = t, t;
 }
-async function A(s, r) {
+async function b(s, r) {
   const t = Pt();
   try {
-    return await r((o, i) => vt(t, o, i), t);
+    return await r((i, o) => vt(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, o, i, n, a, c) {
+  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 = o, this.onClose = i, this.onError = n, this.onCloseAndError = a, this.onCloseAndErrorNoStop = c;
+    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 A(this.logger, async (r, t) => {
+    await b(this.logger, async (r, t) => {
       this.wasStopped = !1;
       const e = st(this.logger, this.startOptions);
-      e.on("error", (i) => {
+      e.on("error", (o) => {
         this.logger.error(
-          `error '${i}', while running platforma, started opts: ${JSON.stringify(this.debugInfo())}`
+          `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);
       }), r("started", !0);
-      const o = r("pidFile", j(this.workingDir));
-      r("pid", p(e.pid)), r("pidWritten", await $t(o, p(e.pid))), this.nRuns++, this.instance = e, this.pid = e.pid, this.lastRunHistory = t;
+      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;
     });
   }
   stop() {
-    this.wasStopped = !0, U(p(this.pid));
+    this.wasStopped = !0, T(p(this.pid));
   }
   async waitStopped() {
     await B(p(this.pid), 15e3);
@@ -255,18 +255,18 @@ async function Xt(s, r) {
     closeOld: !0,
     ...r
   };
-  return await A(s, async (e, o) => {
+  return await b(s, async (e, i) => {
     e("startOptions", { ...t, config: "too wordy" });
-    const i = h.resolve(t.workingDir);
-    t.closeOld && e("closeOld", await Ct(s, i));
-    const n = h.join(i, St);
+    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 yt(s, h.join(i, "binaries"), t.plBinary), l = {
-      cmd: e("binaryPath", h.join("binaries", a)),
+    const a = await gt(s, u.join(o, "binaries"), t.plBinary), l = {
+      cmd: e("binaryPath", u.join("binaries", a)),
       args: ["-config", n],
       opts: {
         env: { ...process.env },
-        cwd: i,
+        cwd: o,
         stdio: ["pipe", "ignore", "inherit"],
         windowsHide: !0,
         // hide a terminal on Windows
@@ -278,26 +278,26 @@ async function Xt(s, r) {
       args: l.args,
       cwd: l.opts.cwd
     });
-    const u = new Et(
+    const h = new Et(
       s,
       t.workingDir,
       l,
-      o,
+      i,
       t.onClose,
       t.onError,
       t.onCloseAndError,
       t.onCloseAndErrorNoStop
     );
-    return await u.start(), u;
+    return await h.start(), h;
   });
 }
 async function Ct(s, r) {
-  return await A(s, async (t, e) => {
-    const o = t("pidFilePath", j(r)), i = t("pid", await gt(o)), n = t("wasAlive", await C(i));
-    return i !== void 0 && n && (t("stopped", U(i)), t("waitStopped", await B(i, 1e4))), e;
+  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;
   });
 }
-const bt = {
+const Ft = {
   keepaliveInterval: 6e4,
   keepaliveCountMax: 10
 };
@@ -314,10 +314,18 @@ class D {
    */
   static async init(r, t) {
     const e = {
-      ...bt,
+      ...Ft,
       ...t
-    }, o = new D(r, new v());
-    return await o.connect(e), o;
+    }, i = new D(r, new v());
+    return await i.connect(e), i;
+  }
+  getFullHostName() {
+    var r, t;
+    return `${(r = this.config) == null ? void 0 : r.host}:${(t = this.config) == null ? void 0 : t.port}`;
+  }
+  getUserName() {
+    var r;
+    return (r = this.config) == null ? void 0 : r.username;
   }
   /**
    * Connects to the SSH server using the specified configuration.
@@ -328,8 +336,8 @@ class D {
     return this.config = r, new Promise((t, e) => {
       this.client.on("ready", () => {
         t(void 0);
-      }).on("error", (o) => {
-        e(new Error(`ssh.connect: error occurred: ${o}`));
+      }).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);
@@ -342,11 +350,11 @@ class D {
    */
   async exec(r) {
     return new Promise((t, e) => {
-      this.client.exec(r, (o, i) => {
-        if (o)
-          return e(`ssh.exec: ${r}, error occurred: ${o}`);
+      this.client.exec(r, (i, o) => {
+        if (i)
+          return e(`ssh.exec: ${r}, error occurred: ${i}`);
         let n = "", a = "";
-        i.on("close", (c) => {
+        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();
@@ -364,20 +372,20 @@ class D {
    */
   static async getAuthTypes(r, t) {
     return new Promise((e) => {
-      let o = "";
-      const i = new v();
-      i.on("ready", () => {
-        i.end();
-        const n = this.extractAuthMethods(o);
+      let i = "";
+      const o = new v();
+      o.on("ready", () => {
+        o.end();
+        const n = this.extractAuthMethods(i);
         e(n.length === 0 ? ["publickey", "password"] : n);
-      }), i.on("error", () => {
-        i.end(), e(["publickey", "password"]);
-      }), i.connect({
+      }), o.on("error", () => {
+        o.end(), e(["publickey", "password"]);
+      }), o.connect({
         host: r,
         port: t,
         username: (/* @__PURE__ */ new Date()).getTime().toString(),
         debug: (n) => {
-          o += `${n}
+          i += `${n}
 `;
         }
       });
@@ -400,16 +408,16 @@ 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, o) => {
+    return t = t ?? this.config, new Promise((e, i) => {
       if (!t) {
-        o("No config defined");
+        i("No config defined");
         return;
       }
-      const i = new v();
+      const o = new v();
       let n;
-      i.on("ready", () => {
-        this.logger.info(`[SSH] Connection to ${t.host}. Remote port ${r.remotePort} will be available locally on the ${r.localPort}`), n = T.createServer({ pauseOnConnect: !0 }, (a) => {
-          i.forwardOut(
+      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",
@@ -425,15 +433,15 @@ class D {
         }), 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) => {
-          i.end(), n.close(), o(new Error(`ssh.forwardPort: server 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)}`), i && (this.logger.info("End SSH connection"), i.end());
+          this.logger.info(`Server closed ${JSON.stringify(r)}`), o && (this.logger.info("End SSH connection"), o.end());
         });
-      }), i.on("error", (a) => {
-        this.logger.error(`[SSH] SSH connection error, ports: ${JSON.stringify(r)}, err: ${a.message}`), n == null || n.close(), o(`ssh.forwardPort: conn.err: ${a}`);
-      }), i.on("close", () => {
+      }), 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)}`);
-      }), i.connect(t);
+      }), o.connect(t);
     });
   }
   /**
@@ -443,7 +451,7 @@ class D {
   */
   static async checkHostAvailability(r) {
     return new Promise((t) => {
-      ot.lookup(r, (e) => {
+      it.lookup(r, (e) => {
         t(!e);
       });
     });
@@ -457,8 +465,8 @@ class D {
     return new Promise((t, e) => {
       try {
         return et.utils.parseKey(r) instanceof Error && t(!0), t(!1);
-      } catch (o) {
-        console.log("Error parsing privateKey"), e(new Error(`ssh.isPassphraseRequiredForKey: err ${o}`));
+      } catch (i) {
+        console.log("Error parsing privateKey"), e(new Error(`ssh.isPassphraseRequiredForKey: err ${i}`));
       }
     });
   }
@@ -470,15 +478,15 @@ class D {
    * @returns A promise resolving with `true` if the file was successfully uploaded.
    */
   async uploadFile(r, t) {
-    return await this.withSftp(async (e) => new Promise((o, i) => {
+    return await this.withSftp(async (e) => new Promise((i, o) => {
       e.fastPut(r, t, (n) => {
         if (n) {
           const a = new Error(
             `ssh.uploadFile: err: ${n}, localPath: ${r}, remotePath: ${t}`
           );
-          return i(a);
+          return o(a);
         }
-        o(!0);
+        i(!0);
       });
     }));
   }
@@ -489,48 +497,97 @@ class D {
   }
   async withSftp(r) {
     return new Promise((t, e) => {
-      this.client.sftp((o, i) => {
-        if (o)
-          return e(new Error(`ssh.withSftp: sftp err: ${o}`));
-        r(i).then(t).catch((n) => {
+      this.client.sftp((i, o) => {
+        if (i)
+          return e(new Error(`ssh.withSftp: sftp err: ${i}`));
+        r(o).then(t).catch((n) => {
           e(new Error(`ssh.withSftp.callback: err ${n}`));
         }).finally(() => {
-          i == null || i.end();
+          o == null || o.end();
         });
       });
     });
   }
   async writeFileOnTheServer(r, t, e = 432) {
-    return this.withSftp(async (o) => this.writeFile(o, r, t, e));
+    return this.withSftp(async (i) => this.writeFile(i, r, t, e));
+  }
+  async getForderStructure(r, t, e = { files: [], directories: [] }) {
+    return new Promise((i, o) => {
+      r.readdir(t, async (n, a) => {
+        if (n)
+          return o(n);
+        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);
+            } catch (h) {
+              return o(h);
+            }
+          } else
+            e.files.push(l);
+        }
+        i(e);
+      });
+    });
+  }
+  rmdir(r, t) {
+    return new Promise((e, i) => {
+      r.rmdir(t, (o) => o ? i(o) : e(!0));
+    });
+  }
+  unlink(r, t) {
+    return new Promise((e, i) => {
+      r.unlink(t, (o) => o ? i(o) : e(!0));
+    });
+  }
+  async deleteFolder(r) {
+    return this.withSftp(async (t) => {
+      try {
+        const e = await this.getForderStructure(t, r);
+        this.logger.info("ssh.deleteFolder list of files and directories"), this.logger.info(`ssh.deleteFolder list of files: ${e.files}`), this.logger.info(`ssh.deleteFolder list of directories: ${e.directories}`);
+        for (const i of e.files)
+          this.logger.info(`ssh.deleteFolder unlink file ${i}`), await this.unlink(t, i);
+        e.directories.sort((i, o) => o.length - i.length);
+        for (const i of e.directories)
+          this.logger.info(`ssh.deleteFolder rmdir  ${i}`), await this.rmdir(t, i);
+        return await this.rmdir(t, r), !0;
+      } catch (e) {
+        this.logger.error(e);
+        const i = e instanceof Error ? e.message : "";
+        throw new Error(`ssh.deleteFolder: path: ${r}, message: ${i}`);
+      }
+    });
   }
   async readFile(r) {
-    return this.withSftp(async (t) => new Promise((e, o) => {
-      t.readFile(r, (i, n) => {
-        if (i)
-          return o(new Error(`ssh.readFile: err occurred ${i}`));
+    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(r, t) {
-    return this.withSftp(async (e) => new Promise((o, i) => {
-      e.chmod(r, t, (n) => n ? i(new Error(`ssh.chmod: ${n}, path: ${r}, mode: ${t}`)) : o(void 0));
+    return this.withSftp(async (e) => new Promise((i, o) => {
+      e.chmod(r, t, (n) => n ? o(new Error(`ssh.chmod: ${n}, path: ${r}, mode: ${t}`)) : i(void 0));
     }));
   }
   async checkFileExists(r) {
-    return this.withSftp(async (t) => new Promise((e, o) => {
-      t.stat(r, (i, n) => {
-        if (i)
-          return i.code === 2 ? e(!1) : o(new Error(`ssh.checkFileExists: err ${i}`));
+    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}`));
         e(n.isFile());
       });
     }));
   }
   async checkPathExists(r) {
-    return this.withSftp(async (t) => new Promise((e, o) => {
-      t.stat(r, (i, n) => {
-        if (i)
-          return i.code === 2 ? e({ exists: !1, isFile: !1, isDirectory: !1 }) : o(new Error(`ssh.checkPathExists: ${i}`));
+    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({
           exists: !0,
           isFile: n.isFile(),
@@ -539,20 +596,20 @@ class D {
       });
     }));
   }
-  async writeFile(r, t, e, o = 432) {
-    return new Promise((i, n) => {
-      r.writeFile(t, e, { mode: o }, (a) => {
+  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}`));
-        i(!0);
+        o(!0);
       });
     });
   }
-  uploadFileUsingExistingSftp(r, t, e, o = 432) {
-    return new Promise((i, n) => {
+  uploadFileUsingExistingSftp(r, t, e, i = 432) {
+    return new Promise((o, n) => {
       Z(t).then(async (a) => {
-        this.writeFile(r, e, a, o).then(() => {
-          i(void 0);
+        this.writeFile(r, e, a, i).then(() => {
+          o(void 0);
         }).catch((c) => {
           const l = `uploadFileUsingExistingSftp: error ${c} occurred`;
           this.logger.error(l), n(new Error(l));
@@ -560,21 +617,21 @@ class D {
       });
     });
   }
-  async __uploadDirectory(r, t, e, o = 432) {
-    return new Promise((i, n) => {
+  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}`));
         try {
           await this.__createRemoteDirectory(r, e);
           for (const l of c) {
-            const u = h.join(t, l), m = `${e}/${l}`;
-            E.lstatSync(u).isDirectory() ? await this.__uploadDirectory(r, u, m, o) : await this.uploadFileUsingExistingSftp(r, u, m, o);
+            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);
           }
-          i();
+          o();
         } catch (l) {
-          const u = `ssh.__uploadDir: catched err ${l}`;
-          this.logger.error(u), n(new Error(u));
+          const h = `ssh.__uploadDir: catched err ${l}`;
+          this.logger.error(h), n(new Error(h));
         }
       });
     });
@@ -586,9 +643,9 @@ class D {
    * @returns A promise that resolves when the directory and its contents are uploaded.
    */
   async uploadDirectory(r, t, e = 432) {
-    return new Promise((o, i) => {
+    return new Promise((i, o) => {
       this.withSftp(async (n) => {
-        await this.__uploadDirectory(n, r, t, e), o();
+        await this.__uploadDirectory(n, r, t, e), i();
       });
     });
   }
@@ -599,16 +656,16 @@ class D {
    * @returns A promise that resolves when the directory is created.
    */
   __createRemoteDirectory(r, t) {
-    return new Promise((e, o) => {
-      const i = t.split("/");
+    return new Promise((e, i) => {
+      const o = t.split("/");
       let n = "";
       const a = (c) => {
-        if (c >= i.length)
+        if (c >= o.length)
           return e();
-        n += `${i[c]}/`, r.stat(n, (l) => {
-          l ? r.mkdir(n, (u) => {
-            if (u)
-              return o(new Error(`ssh.__createRemDir: err ${u}, remotePath: ${t}`));
+        n += `${o[c]}/`, 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);
         });
@@ -624,23 +681,23 @@ class D {
    */
   createRemoteDirectory(r, t = 493) {
     return this.withSftp(async (e) => {
-      const o = r.split("/");
-      let i = "";
-      for (const n of o) {
-        i += `${n}/`;
+      const i = r.split("/");
+      let o = "";
+      for (const n of i) {
+        o += `${n}/`;
         try {
           await new Promise((a, c) => {
-            e.stat(i, (l) => {
+            e.stat(o, (l) => {
               if (!l) return a();
-              e.mkdir(i, { mode: t }, (u) => {
-                if (u)
-                  return c(new Error(`ssh.createRemoteDir: err ${u}, remotePath: ${r}`));
+              e.mkdir(o, { mode: t }, (h) => {
+                if (h)
+                  return c(new Error(`ssh.createRemoteDir: err ${h}, remotePath: ${r}`));
                 a();
               });
             });
           });
         } catch (a) {
-          throw console.error(`Failed to create directory: ${i}`, a), a;
+          throw console.error(`Failed to create directory: ${o}`, a), a;
         }
       }
     });
@@ -652,11 +709,11 @@ class D {
    * @returns A promise resolving with `true` if the file was successfully downloaded.
    */
   async downloadFile(r, t) {
-    return this.withSftp(async (e) => new Promise((o, i) => {
+    return this.withSftp(async (e) => new Promise((i, o) => {
       e.fastGet(r, t, (n) => {
         if (n)
-          return i(new Error(`ssh.downloadFile: err ${n}, remotePath: ${r}, localPath: ${t}`));
-        o(!0);
+          return o(new Error(`ssh.downloadFile: err ${n}, remotePath: ${r}, localPath: ${t}`));
+        i(!0);
       });
     }));
   }
@@ -667,65 +724,65 @@ class D {
     this.client.end();
   }
 }
-const At = "minio-2024-12-18T13-15-44Z", Dt = "supervisord-0.7.3", Ft = "supervisord_0.7.3_Linux_64-bit";
-function $(s) {
-  return h.join(s, "platforma_ssh");
+const bt = "minio-2024-12-18T13-15-44Z", Dt = "supervisord-0.7.3", At = "supervisord_0.7.3_Linux_64-bit";
+function y(s) {
+  return u.join(s, "platforma_ssh");
 }
 function P(s) {
-  return h.join(s, "platforma_ssh", "binaries");
+  return u.join(s, "platforma_ssh", "binaries");
 }
-function xt(s, r) {
-  return h.join(P(s), `pl-${b()}-${g(r)}`);
+function kt(s, r) {
+  return u.join(P(s), `pl-${F()}-${$(r)}`);
 }
 function J(s, r) {
-  return h.join(xt(s, r), "binaries");
+  return u.join(kt(s, r), "binaries");
 }
-function O(s, r) {
-  return h.join(J(s, r), "platforma");
+function x(s, r) {
+  return u.join(J(s, r), "platforma");
 }
-function Ot(s, r) {
-  return h.join(J(s, r), "free-port");
+function xt(s, r) {
+  return u.join(J(s, r), "free-port");
 }
 function M(s, r) {
-  return h.join(P(s), `minio-2024-12-18T13-15-44Z-${g(r)}`);
+  return u.join(P(s), `minio-2024-12-18T13-15-44Z-${$(r)}`);
 }
-function kt(s, r) {
-  return h.join(M(s, r), "minio");
+function Ot(s, r) {
+  return u.join(M(s, r), "minio");
 }
 function Rt(s, r) {
-  return h.join(P(s), `supervisord-0.7.3-${g(r)}`, Ft);
+  return u.join(P(s), `supervisord-0.7.3-${$(r)}`, At);
 }
 function L(s, r) {
-  return h.join(Rt(s, r), "supervisord");
+  return u.join(Rt(s, r), "supervisord");
 }
 function z(s) {
-  return h.join($(s), "supervisor.conf");
+  return u.join(y(s), "supervisor.conf");
 }
-function k(s) {
-  return h.join($(s), "connection.txt");
+function O(s) {
+  return u.join(y(s), "connection.txt");
 }
 async function Nt(s, r, t) {
-  const e = await F(s, r, t, "--daemon");
+  const e = await A(s, r, t, "--daemon");
   if (e.stderr)
     throw new Error(`Can not run ssh Platforma ${e.stderr}`);
 }
-async function Tt(s, r, t) {
-  const e = await F(s, r, t, "ctl shutdown");
+async function Ut(s, r, t) {
+  const e = await A(s, r, t, "ctl shutdown");
   if (e.stderr)
     throw new Error(`Can not stop ssh Platforma ${e.stderr}`);
 }
-async function Ut(s, r, t, e) {
-  const o = await F(r, t, e, "ctl status");
-  if (o.stderr)
-    return s.info(`supervisord ctl status: stderr occurred: ${o.stderr}, stdout: ${o.stdout}`), !1;
-  const i = {
-    platforma: R(o.stdout, "platforma"),
-    minio: R(o.stdout, "minio")
+async function Tt(s, r, t, e) {
+  const i = await A(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")
   };
-  return i.platforma && i.minio ? !0 : (i.minio || s.warn("Minio is not running on the server"), i.platforma || s.warn("Platforma is not running on the server"), !1);
+  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, o, i, n) {
-  const a = Object.entries(r).map(([u, m]) => `${u}="${m}"`).join(","), c = nt(16).toString("hex"), l = t;
+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;
   return `
 [supervisord]
 logfile=${e}/supervisord.log
@@ -745,27 +802,27 @@ password=${c}
 [program:platforma]
 autostart=true
 depends_on=minio
-command=${n} --config ${o}
+command=${n} --config ${i}
 directory=${e}
 autorestart=true
 
 [program:minio]
 autostart=true
 environment=${a}
-command=${i} server ${s}
+command=${o} server ${s}
 directory=${e}
 autorestart=true
 `;
 }
-async function F(s, r, t, e) {
-  const o = L(r, t), i = z(r), n = `${o} --configuration ${i} ${e}`;
+async function A(s, r, t, e) {
+  const i = L(r, t), o = z(r), n = `${i} --configuration ${o} ${e}`;
   return await s.exec(n);
 }
 function R(s, r) {
-  return ((o) => o.replace(/\x1B\[[0-9;]*m/g, ""))(s).split(`
-`).some((o) => {
-    const [i, n] = o.trim().split(/\s{2,}/);
-    return i === r && n === "Running";
+  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 {
@@ -790,7 +847,7 @@ class W {
   async isAlive() {
     const r = await this.getArch(), t = await this.getUserHomeDirectory();
     try {
-      return await Ut(this.logger, this.sshClient, t, r.arch);
+      return await Tt(this.logger, this.sshClient, t, r.arch);
     } catch {
       return !1;
     }
@@ -800,19 +857,23 @@ class W {
     try {
       return await Nt(this.sshClient, t, r.arch), await this.checkIsAliveWithInterval();
     } catch (e) {
-      const o = `ssh.start: error occurred ${e}`;
-      throw this.logger.error(o), new Error(o);
+      const i = `ssh.start: error occurred ${e}`;
+      throw this.logger.error(i), new Error(i);
     }
   }
   async stop() {
     const r = await this.getArch(), t = await this.getUserHomeDirectory();
     try {
-      return await Tt(this.sshClient, t, r.arch), await this.checkIsAliveWithInterval(void 0, void 0, !1);
+      return await Ut(this.sshClient, t, r.arch), await this.checkIsAliveWithInterval(void 0, void 0, !1);
     } catch (e) {
-      const o = `ssh.stop: error occurred ${e}`;
-      throw this.logger.error(o), new Error(o);
+      const i = `ssh.stop: error occurred ${e}`;
+      throw this.logger.error(i), new Error(i);
     }
   }
+  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;
+  }
   async platformaInit(r) {
     const t = { localWorkdir: r };
     try {
@@ -828,9 +889,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 o = await it({
+      const i = await ot({
         logger: this.logger,
-        workingDir: $(t.remoteHome),
+        workingDir: y(t.remoteHome),
         portsMode: {
           type: "customWithMinio",
           ports: {
@@ -847,50 +908,50 @@ class W {
           type: "env"
         }
       });
-      t.generatedConfig = { ...o, filesToCreate: { skipped: "it is too wordy" } };
-      for (const [a, c] of Object.entries(o.filesToCreate))
+      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 o.dirsToCreate)
+      for (const a of i.dirsToCreate)
         await this.sshClient.createRemoteDirectory(a), this.logger.info(`Created directory ${a}`);
-      const i = Bt(
-        o.minioConfig.storageDir,
-        o.minioConfig.envs,
+      const o = Bt(
+        i.minioConfig.storageDir,
+        i.minioConfig.envs,
         await this.getFreePortForPlatformaOnServer(t.remoteHome, t.arch),
-        o.workingDir,
-        o.plConfig.configPath,
+        i.workingDir,
+        i.plConfig.configPath,
         t.binPaths.minioRelPath,
         t.binPaths.downloadedPl
       );
-      if (!await this.sshClient.writeFileOnTheServer(z(t.remoteHome), i))
-        throw new Error(`Can not write supervisord config on the server ${$(t.remoteHome)}`);
+      if (!await this.sshClient.writeFileOnTheServer(z(t.remoteHome), o))
+        throw new Error(`Can not write supervisord config on the server ${y(t.remoteHome)}`);
       return t.connectionInfo = {
-        plUser: o.plUser,
-        plPassword: o.plPassword,
+        plUser: i.plUser,
+        plPassword: i.plPassword,
         ports: t.ports
       }, await this.sshClient.writeFileOnTheServer(
-        k(t.remoteHome),
+        O(t.remoteHome),
         JSON.stringify(t.connectionInfo, void 0, 2)
       ), await this.start(), t.started = !0, this.initState = t, {
-        plUser: o.plUser,
-        plPassword: o.plPassword,
+        plUser: i.plUser,
+        plPassword: i.plPassword,
         ports: t.ports
       };
     } catch (e) {
-      const o = `SshPl.platformaInit: error occurred: ${e}, state: ${JSON.stringify(t)}`;
-      throw this.logger.error(o), new Error(o);
+      const i = `SshPl.platformaInit: error occurred: ${e}, state: ${JSON.stringify(t)}`;
+      throw this.logger.error(i), new Error(i);
     }
   }
   async downloadBinariesAndUploadToTheServer(r, t, e) {
-    const o = [];
+    const i = [];
     try {
-      const i = await this.downloadAndUntar(
+      const o = await this.downloadAndUntar(
         r,
         t,
         e,
         "pl",
-        `pl-${b()}`
+        `pl-${F()}`
       );
-      o.push(i);
+      i.push(o);
       const n = await this.downloadAndUntar(
         r,
         t,
@@ -898,49 +959,49 @@ class W {
         "supervisord",
         Dt
       );
-      o.push(n);
-      const a = kt(t, e.arch), c = await this.downloadAndUntar(
+      i.push(n);
+      const a = Ot(t, e.arch), c = await this.downloadAndUntar(
         r,
         t,
         e,
         "minio",
-        At
+        bt
       );
-      return o.push(c), await this.sshClient.chmod(a, 488), {
-        history: o,
+      return i.push(c), await this.sshClient.chmod(a, 488), {
+        history: i,
         minioRelPath: a,
-        downloadedPl: O(t, e.arch)
+        downloadedPl: x(t, e.arch)
       };
-    } catch (i) {
-      const n = `SshPl.downloadBinariesAndUploadToServer: error ${i} occurred, state: ${JSON.stringify(o)}`;
-      throw this.logger.error(n), i;
+    } catch (o) {
+      const n = `SshPl.downloadBinariesAndUploadToServer: error ${o} occurred, state: ${JSON.stringify(i)}`;
+      throw this.logger.error(n), o;
     }
   }
   /** 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(r, t, e, o, i) {
+  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 u = 1; u <= c; u++)
+    for (let h = 1; h <= c; h++)
       try {
         a = await lt(
           this.logger,
           r,
-          o,
           i,
+          o,
           e.arch,
           e.platform
         );
         break;
       } catch (m) {
-        if (await S(300), u == c)
+        if (await S(300), h == c)
           throw new Error(`downloadAndUntar: ${c} attempts, last error: ${m}`);
       }
-    n.downloadResult = p(a), n.localArchivePath = h.resolve(n.downloadResult.archivePath), n.remoteDir = h.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 = 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);
     const l = await this.sshClient.exec(
       `tar xvf ${n.remoteArchivePath} --directory=${n.remoteDir}`
     );
@@ -949,60 +1010,60 @@ class W {
     return n.plUntarDone = !0, n;
   }
   async needDownload(r, t) {
-    const e = L(r, t.arch), o = M(r, t.arch), i = O(r, t.arch);
-    return !await this.sshClient.checkFileExists(i) || !await this.sshClient.checkFileExists(o) || !await this.sshClient.checkFileExists(e);
+    const e = L(r, t.arch), i = M(r, t.arch), o = x(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 o = t * r;
-    let i = 0, n = await this.isAlive();
+    const i = t * r;
+    let o = 0, n = await this.isAlive();
     for (; e ? !n : n; ) {
-      if (await S(r), i += r, i > o)
-        throw new Error(`isAliveWithInterval: The process did not ${e ? "started" : "stopped"} after ${o} ms.`);
+      if (await S(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(k(r));
+    const t = await this.sshClient.readFile(O(r));
     return JSON.parse(t);
   }
   async fetchPorts(r, t) {
     return {
       grpc: {
-        local: await y(),
+        local: await g(),
         remote: await this.getFreePortForPlatformaOnServer(r, t)
       },
       monitoring: {
-        local: await y(),
+        local: await g(),
         remote: await this.getFreePortForPlatformaOnServer(r, t)
       },
       debug: {
-        local: await y(),
+        local: await g(),
         remote: await this.getFreePortForPlatformaOnServer(r, t)
       },
       minioPort: {
-        local: await y(),
+        local: await g(),
         remote: await this.getFreePortForPlatformaOnServer(r, t)
       },
       minioConsolePort: {
-        local: await y(),
+        local: await g(),
         remote: await this.getFreePortForPlatformaOnServer(r, t)
       }
     };
   }
   async getLocalFreePort() {
     return new Promise((r) => {
-      const t = T.createServer();
+      const t = U.createServer();
       t.listen(0, () => {
         const e = t.address().port;
-        t.close((o) => r(e));
+        t.close((i) => r(e));
       });
     });
   }
   async getFreePortForPlatformaOnServer(r, t) {
-    const e = Ot(r, t.arch), { stdout: o, stderr: i } = await this.sshClient.exec(`${e}`);
-    if (i)
-      throw new Error(`getFreePortForPlatformaOnServer: stderr is not empty: ${i}, stdout: ${o}`);
-    return +o;
+    const e = xt(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: r, stderr: t } = await this.sshClient.exec("uname -s && uname -m");
@@ -1029,7 +1090,7 @@ export {
   Et as LocalPl,
   D as SshClient,
   W as SshPl,
-  b as getDefaultPlVersion,
+  F as getDefaultPlVersion,
   Xt as localPlatformaInit
 };
 //# sourceMappingURL=index.mjs.map