@milaboratories/pl-deployments 1.1.0

package/dist/index.mjs

@@ -0,0 +1,1028 @@
+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";
+import E from "node:fs";
+import w, { readFile as Z } from "node:fs/promises";
+import h 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 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 { randomBytes as nt } from "node:crypto";
+function st(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);
+}
+async function C(s) {
+  try {
+    return process.kill(s, 0), !0;
+  } catch {
+    return !1;
+  }
+}
+function U(s) {
+  return process.kill(s, "SIGINT");
+}
+async function B(s, r) {
+  let e = 0;
+  for (; await C(s); )
+    if (await S(100), e += 100, e > r)
+      throw new Error(`The process did not stopped after ${r} ms.`);
+}
+const at = ["linux", "macos", "windows"];
+function _(s) {
+  switch (s.toLowerCase()) {
+    case "darwin":
+      return "macos";
+    case "linux":
+      return "linux";
+    case "win32":
+      return "windows";
+    default:
+      throw new Error(
+        `operating system '${s}' is not currently supported by Platforma ecosystem. The list of OSes supported: ` + JSON.stringify(at)
+      );
+  }
+}
+const ct = ["amd64", "arm64"];
+function g(s) {
+  switch (s) {
+    case "aarch64":
+    case "aarch64_be":
+    case "arm64":
+      return "arm64";
+    case "x86_64":
+    case "x64":
+      return "amd64";
+    default:
+      throw new Error(
+        `processor architecture '${s}' is not currently supported by Platforma ecosystem. The list of architectures supported: ` + JSON.stringify(ct)
+      );
+  }
+}
+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 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;
+}
+function ut(s, r, t, e, o) {
+  const i = `${r}-${e}`, n = j[o], a = `${i}.${n}`, c = `https://cdn.platforma.bio/software/${s}/${o}/${a}`, l = h.join(t, a), u = h.join(t, i);
+  return {
+    archiveUrl: c,
+    archivePath: l,
+    archiveType: n,
+    targetFolder: u,
+    baseName: i
+  };
+}
+function dt(s, r, t, e) {
+  const o = `pl-${s}-${t}`, i = j[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]);
+  return {
+    archiveUrl: a,
+    archivePath: c,
+    archiveType: i,
+    targetFolder: l,
+    binaryPath: u,
+    baseName: o
+  };
+}
+async function H(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:
+  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);
+    }
+    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);
+  }
+}
+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 = h.join(e, wt);
+  if (await f(o)) {
+    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(
+    `Unpacking Platforma Backend archive:
+  Archive:   ${r}
+  Target dir: ${e}`
+  ), t) {
+    case "tgz":
+      await tt.x({
+        file: r,
+        cwd: e,
+        gzip: !0
+      });
+      break;
+    case "zip":
+      await rt(r, e);
+      break;
+    default:
+      N(t);
+  }
+  await w.writeFile(o, "ok"), s.info("  ... unpack done.");
+}
+const j = {
+  linux: "tgz",
+  macos: "tgz",
+  windows: "zip"
+}, ft = {
+  linux: "platforma",
+  macos: "platforma",
+  windows: "platforma.exe"
+};
+function b() {
+  return "1.18.3";
+}
+function mt() {
+  return { type: "Download", version: b() };
+}
+async function yt(s, r, t) {
+  switch (t.type) {
+    case "Download":
+      return (await ht(s, r, t.version, x.arch(), x.platform())).binaryPath;
+    case "Local":
+      return t.path;
+    default:
+      N(t);
+  }
+}
+function I(s) {
+  return h.join(s, "pl_pid");
+}
+async function gt(s) {
+  if (!await f(s))
+    return;
+  const r = await w.readFile(s);
+  return Number(r.toString());
+}
+async function $t(s, r) {
+  await w.writeFile(s, JSON.stringify(r));
+}
+function Pt() {
+  return {};
+}
+function vt(s, r, t) {
+  return s[r] = t, t;
+}
+async function A(s, r) {
+  const t = Pt();
+  try {
+    return await r((o, i) => vt(t, o, i), 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) {
+    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;
+  }
+  async start() {
+    await A(this.logger, async (r, t) => {
+      this.wasStopped = !1;
+      const e = st(this.logger, this.startOptions);
+      e.on("error", (i) => {
+        this.logger.error(
+          `error '${i}', 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", I(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;
+    });
+  }
+  stop() {
+    this.wasStopped = !0, U(p(this.pid));
+  }
+  async waitStopped() {
+    await B(p(this.pid), 15e3);
+  }
+  stopped() {
+    return this.wasStopped;
+  }
+  async isAlive() {
+    return await C(p(this.pid));
+  }
+  debugInfo() {
+    return {
+      lastRunHistory: this.lastRunHistory,
+      nRuns: this.nRuns,
+      pid: this.pid,
+      workingDir: this.workingDir,
+      initialStartHistory: this.initialStartHistory,
+      wasStopped: this.wasStopped
+    };
+  }
+}
+async function Qt(s, r) {
+  const t = {
+    plBinary: mt(),
+    spawnOptions: {},
+    closeOld: !0,
+    ...r
+  };
+  return await A(s, async (e, o) => {
+    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);
+    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)),
+      args: ["-config", n],
+      opts: {
+        env: { ...process.env },
+        cwd: i,
+        stdio: ["pipe", "ignore", "inherit"],
+        windowsHide: !0,
+        // hide a terminal on Windows
+        ...t.spawnOptions
+      }
+    };
+    e("processOpts", {
+      cmd: l.cmd,
+      args: l.args,
+      cwd: l.opts.cwd
+    });
+    const u = new Et(
+      s,
+      t.workingDir,
+      l,
+      o,
+      t.onClose,
+      t.onError,
+      t.onCloseAndError,
+      t.onCloseAndErrorNoStop
+    );
+    return await u.start(), u;
+  });
+}
+async function Ct(s, r) {
+  return await A(s, async (t, e) => {
+    const o = t("pidFilePath", I(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;
+  });
+}
+class F {
+  constructor(r, t) {
+    d(this, "config");
+    d(this, "homeDir");
+    this.logger = r, this.client = t;
+  }
+  /**
+   * Initializes the SshClient and establishes a connection using the provided configuration.
+   * @param config - The connection configuration object for the SSH client.
+   * @returns A new instance of SshClient with an active connection.
+   */
+  static async init(r, t) {
+    const e = new F(r, new v());
+    return await e.connect(t), e;
+  }
+  /**
+   * Connects to the SSH server using the specified configuration.
+   * @param config - The connection configuration object for the SSH client.
+   * @returns A promise that resolves when the connection is established or rejects on error.
+   */
+  async connect(r) {
+    return this.config = r, new Promise((t, e) => {
+      this.client.on("ready", () => {
+        t(void 0);
+      }).on("error", (o) => {
+        e(new Error(`ssh.connect: error occurred: ${o}`));
+      }).on("timeout", () => {
+        e(new Error("timeout was occurred while waiting for SSH connection."));
+      }).connect(r);
+    });
+  }
+  /**
+   * Executes a command on the SSH server.
+   * @param command - The command to execute on the remote server.
+   * @returns A promise resolving with the command's stdout and stderr outputs.
+   */
+  async exec(r) {
+    return new Promise((t, e) => {
+      this.client.exec(r, (o, i) => {
+        if (o)
+          return e(`ssh.exec: ${r}, error occurred: ${o}`);
+        let n = "", a = "";
+        i.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();
+        });
+      });
+    });
+  }
+  /**
+   * Retrieves the supported authentication methods for a given host and port.
+   * @param host - The hostname or IP address of the server.
+   * @param port - The port number to connect to on the server.
+   * @returns 'publickey' | 'password'[] A promise resolving with a list of supported authentication methods.
+   */
+  static async getAuthTypes(r, t) {
+    return new Promise((e) => {
+      let o = "";
+      const i = new v();
+      i.on("ready", () => {
+        i.end();
+        const n = this.extractAuthMethods(o);
+        e(n.length === 0 ? ["publickey", "password"] : n);
+      }), i.on("error", () => {
+        i.end(), e(["publickey", "password"]);
+      }), i.connect({
+        host: r,
+        port: t,
+        username: (/* @__PURE__ */ new Date()).getTime().toString(),
+        debug: (n) => {
+          o += `${n}
+`;
+        }
+      });
+    });
+  }
+  /**
+   * Extracts authentication methods from debug logs.
+   * @param log - The debug log output containing authentication information.
+   * @returns An array of extracted authentication methods.
+   */
+  static extractAuthMethods(r) {
+    const t = r.match(/Inbound: Received USERAUTH_FAILURE \((.+)\)/);
+    return t && t[1] ? t[1].split(",").map((e) => e.trim()) : [];
+  }
+  /**
+   * Sets up port forwarding between a remote port on the SSH server and a local port.
+   * A new connection is used for this operation instead of an existing one.
+   * @param ports - An object specifying the remote and local port configuration.
+   * @param config - Optional connection configuration for the SSH client.
+   * @returns { server: net.Server } A promise resolving with the created server instance.
+   */
+  async forwardPort(r, t) {
+    return t = t ?? this.config, new Promise((e, o) => {
+      if (!t) {
+        o("No config defined");
+        return;
+      }
+      const i = 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(
+            "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) => {
+          i.end(), n.close(), o(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());
+        });
+      }), i.on("error", (a) => {
+        console.error("[SSH] SSH connection error", "ports", r, a.message), n == null || n.close(), o(`ssh.forwardPort: conn.err: ${a}`);
+      }), i.on("close", () => {
+        this.logger.info(`[SSH] Connection closed, ports: ${r}`);
+      }), i.connect(t);
+    });
+  }
+  /**
+  * Checks if a specified host is available by performing a DNS lookup.
+  * @param hostname - The hostname or IP address to check.
+  * @returns A promise resolving with `true` if the host is reachable, otherwise `false`.
+  */
+  static async checkHostAvailability(r) {
+    return new Promise((t) => {
+      ot.lookup(r, (e) => {
+        t(!e);
+      });
+    });
+  }
+  /**
+   * Determines whether a private key requires a passphrase for use.
+   * @param privateKey - The private key content to check.
+   * @returns A promise resolving with `true` if a passphrase is required, otherwise `false`.
+   */
+  static async isPassphraseRequiredForKey(r) {
+    return new Promise((t, e) => {
+      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}`));
+      }
+    });
+  }
+  /**
+   * Uploads a local file to a remote server via SFTP.
+   * This function creates new SFTP connection
+   * @param localPath - The local file path.
+   * @param remotePath - The remote file path on the server.
+   * @returns A promise resolving with `true` if the file was successfully uploaded.
+   */
+  async uploadFile(r, t) {
+    return await this.withSftp(async (e) => new Promise((o, i) => {
+      e.fastPut(r, t, (n) => {
+        if (n) {
+          const a = new Error(
+            `ssh.uploadFile: err: ${n}, localPath: ${r}, remotePath: ${t}`
+          );
+          return i(a);
+        }
+        o(!0);
+      });
+    }));
+  }
+  delay(r) {
+    return new Promise((t, e) => {
+      setTimeout(() => t(), r);
+    });
+  }
+  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) => {
+          e(new Error(`ssh.withSftp.callback: err ${n}`));
+        }).finally(() => {
+          i == null || i.end();
+        });
+      });
+    });
+  }
+  async writeFileOnTheServer(r, t, e = 432) {
+    return this.withSftp(async (o) => this.writeFile(o, r, t, e));
+  }
+  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}`));
+        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));
+    }));
+  }
+  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}`));
+        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}`));
+        e({
+          exists: !0,
+          isFile: n.isFile(),
+          isDirectory: n.isDirectory()
+        });
+      });
+    }));
+  }
+  async writeFile(r, t, e, o = 432) {
+    return new Promise((i, n) => {
+      r.writeFile(t, e, { mode: o }, (a) => {
+        if (a)
+          return n(new Error(`ssh.writeFile: err ${a}, remotePath: ${t}`));
+        i(!0);
+      });
+    });
+  }
+  uploadFileUsingExistingSftp(r, t, e, o = 432) {
+    return new Promise((i, n) => {
+      Z(t).then(async (a) => {
+        this.writeFile(r, e, a, o).then(() => {
+          i(void 0);
+        }).catch((c) => {
+          const l = `uploadFileUsingExistingSftp: error ${c} occurred`;
+          this.logger.error(l), n(new Error(l));
+        });
+      });
+    });
+  }
+  async __uploadDirectory(r, t, e, o = 432) {
+    return new Promise((i, 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);
+          }
+          i();
+        } catch (l) {
+          const u = `ssh.__uploadDir: catched err ${l}`;
+          this.logger.error(u), n(new Error(u));
+        }
+      });
+    });
+  }
+  /**
+   * Uploads a local directory and its contents (including subdirectories) to the remote server via SFTP.
+   * @param localDir - The path to the local directory to upload.
+   * @param remoteDir - The path to the remote directory on the server.
+   * @returns A promise that resolves when the directory and its contents are uploaded.
+   */
+  async uploadDirectory(r, t, e = 432) {
+    return new Promise((o, i) => {
+      this.withSftp(async (n) => {
+        await this.__uploadDirectory(n, r, t, e), o();
+      });
+    });
+  }
+  /**
+   * Ensures that a remote directory and all its parent directories exist.
+   * @param sftp - The SFTP wrapper.
+   * @param remotePath - The path to the remote directory.
+   * @returns A promise that resolves when the directory is created.
+   */
+  __createRemoteDirectory(r, t) {
+    return new Promise((e, o) => {
+      const i = t.split("/");
+      let n = "";
+      const a = (c) => {
+        if (c >= i.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}`));
+            a(c + 1);
+          }) : a(c + 1);
+        });
+      };
+      a(0);
+    });
+  }
+  /**
+   * Ensures that a remote directory and all its parent directories exist.
+   * @param sftp - The SFTP wrapper.
+   * @param remotePath - The path to the remote directory.
+   * @returns A promise that resolves when the directory is created.
+   */
+  createRemoteDirectory(r, t = 493) {
+    return this.withSftp(async (e) => {
+      const o = r.split("/");
+      let i = "";
+      for (const n of o) {
+        i += `${n}/`;
+        try {
+          await new Promise((a, c) => {
+            e.stat(i, (l) => {
+              if (!l) return a();
+              e.mkdir(i, { mode: t }, (u) => {
+                if (u)
+                  return c(new Error(`ssh.createRemoteDir: err ${u}, remotePath: ${r}`));
+                a();
+              });
+            });
+          });
+        } catch (a) {
+          throw console.error(`Failed to create directory: ${i}`, a), a;
+        }
+      }
+    });
+  }
+  /**
+   * Downloads a file from the remote server to a local path via SFTP.
+   * @param remotePath - The remote file path on the server.
+   * @param localPath - The local file path to save the file.
+   * @returns A promise resolving with `true` if the file was successfully downloaded.
+   */
+  async downloadFile(r, t) {
+    return this.withSftp(async (e) => new Promise((o, i) => {
+      e.fastGet(r, t, (n) => {
+        if (n)
+          return i(new Error(`ssh.downloadFile: err ${n}, remotePath: ${r}, localPath: ${t}`));
+        o(!0);
+      });
+    }));
+  }
+  /**
+   * Closes the SSH client connection.
+   */
+  close() {
+    this.client.end();
+  }
+}
+const bt = "minio-2024-12-18T13-15-44Z", At = "supervisord-0.7.3", Ft = "supervisord_0.7.3_Linux_64-bit";
+function $(s) {
+  return h.join(s, "platforma_ssh");
+}
+function P(s) {
+  return h.join(s, "platforma_ssh", "binaries");
+}
+function Dt(s, r) {
+  return h.join(P(s), `pl-${b()}-${g(r)}`);
+}
+function M(s, r) {
+  return h.join(Dt(s, r), "binaries");
+}
+function O(s, r) {
+  return h.join(M(s, r), "platforma");
+}
+function xt(s, r) {
+  return h.join(M(s, r), "free-port");
+}
+function J(s, r) {
+  return h.join(P(s), `minio-2024-12-18T13-15-44Z-${g(r)}`);
+}
+function Ot(s, r) {
+  return h.join(J(s, r), "minio");
+}
+function kt(s, r) {
+  return h.join(P(s), `supervisord-0.7.3-${g(r)}`, Ft);
+}
+function L(s, r) {
+  return h.join(kt(s, r), "supervisord");
+}
+function z(s) {
+  return h.join($(s), "supervisor.conf");
+}
+function k(s) {
+  return h.join($(s), "connection.txt");
+}
+async function Rt(s, r, t) {
+  const e = await D(s, r, t, "--daemon");
+  if (e.stderr)
+    throw new Error(`Can not run ssh Platforma ${e.stderr}`);
+}
+async function Nt(s, r, t) {
+  const e = await D(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 o = await D(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")
+  };
+  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);
+}
+function Ut(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;
+  return `
+[supervisord]
+logfile=${e}/supervisord.log
+loglevel=info
+pidfile=${e}/supervisord.pid
+
+[inet_http_server]
+port=127.0.0.1:${l}
+username=default-user
+password=${c}
+
+[supervisorctl]
+serverurl=http://127.0.0.1:${l}
+username=default-user
+password=${c}
+
+[program:platforma]
+autostart=true
+depends_on=minio
+command=${n} --config ${o}
+directory=${e}
+autorestart=true
+
+[program:minio]
+autostart=true
+environment=${a}
+command=${i} server ${s}
+directory=${e}
+autorestart=true
+`;
+}
+async function D(s, r, t, e) {
+  const o = L(r, t), i = z(r), n = `${o} --configuration ${i} ${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";
+  });
+}
+class W {
+  constructor(r, t, e) {
+    d(this, "initState", {});
+    this.logger = r, this.sshClient = t, this.username = e;
+  }
+  info() {
+    return {
+      username: this.username,
+      initState: this.initState
+    };
+  }
+  static async init(r, t) {
+    try {
+      const e = await F.init(r, t);
+      return new W(r, e, p(t.username));
+    } catch (e) {
+      throw r.error(`Connection error in SshClient.init: ${e}`), e;
+    }
+  }
+  async isAlive() {
+    const r = await this.getArch(), t = await this.getUserHomeDirectory();
+    try {
+      return await Tt(this.logger, this.sshClient, t, r.arch);
+    } catch {
+      return !1;
+    }
+  }
+  async start() {
+    const r = await this.getArch(), t = await this.getUserHomeDirectory();
+    try {
+      return await Rt(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);
+    }
+  }
+  async stop() {
+    const r = await this.getArch(), t = await this.getUserHomeDirectory();
+    try {
+      return await Nt(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);
+    }
+  }
+  async platformaInit(r) {
+    const t = { localWorkdir: r };
+    try {
+      if (t.arch = await this.getArch(), t.remoteHome = await this.getUserHomeDirectory(), t.isAlive = await this.isAlive(), t.isAlive) {
+        if (t.userCredentials = await this.getUserCredentials(t.remoteHome), !t.userCredentials)
+          throw new Error("SshPl.platformaInit: platforma is alive but userCredentials are not found");
+        return t.userCredentials;
+      }
+      const e = await this.downloadBinariesAndUploadToTheServer(
+        r,
+        t.remoteHome,
+        t.arch
+      );
+      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({
+        logger: this.logger,
+        workingDir: $(t.remoteHome),
+        portsMode: {
+          type: "customWithMinio",
+          ports: {
+            debug: t.ports.debug.remote,
+            grpc: t.ports.grpc.remote,
+            minio: t.ports.minioPort.remote,
+            minioConsole: t.ports.minioConsolePort.remote,
+            monitoring: t.ports.monitoring.remote,
+            grpcLocal: t.ports.grpc.local,
+            minioLocal: t.ports.minioPort.local
+          }
+        },
+        licenseMode: {
+          type: "env"
+        }
+      });
+      t.generatedConfig = { ...o, filesToCreate: { skipped: "it is too wordy" } };
+      for (const [a, c] of Object.entries(o.filesToCreate))
+        await this.sshClient.writeFileOnTheServer(a, c), this.logger.info(`Created file ${a}`);
+      for (const a of o.dirsToCreate)
+        await this.sshClient.createRemoteDirectory(a), this.logger.info(`Created directory ${a}`);
+      const i = Ut(
+        o.minioConfig.storageDir,
+        o.minioConfig.envs,
+        await this.getFreePortForPlatformaOnServer(t.remoteHome, t.arch),
+        o.workingDir,
+        o.plConfig.configPath,
+        t.binPaths.minioRelPath,
+        t.binPaths.downloadedPl
+      );
+      if (!await this.sshClient.writeFileOnTheServer(z(t.remoteHome), i))
+        throw new Error(`Can not write supervisord config on the server ${$(t.remoteHome)}`);
+      return t.connectionInfo = {
+        plUser: o.plUser,
+        plPassword: o.plPassword,
+        ports: t.ports
+      }, await this.sshClient.writeFileOnTheServer(
+        k(t.remoteHome),
+        JSON.stringify(t.connectionInfo, void 0, 2)
+      ), await this.start(), t.started = !0, this.initState = t, {
+        plUser: o.plUser,
+        plPassword: o.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);
+    }
+  }
+  async downloadBinariesAndUploadToTheServer(r, t, e) {
+    const o = [];
+    try {
+      const i = await this.downloadAndUntar(
+        r,
+        t,
+        e,
+        "pl",
+        `pl-${b()}`
+      );
+      o.push(i);
+      const n = await this.downloadAndUntar(
+        r,
+        t,
+        e,
+        "supervisord",
+        At
+      );
+      o.push(n);
+      const a = Ot(t, e.arch), c = await this.downloadAndUntar(
+        r,
+        t,
+        e,
+        "minio",
+        bt
+      );
+      return o.push(c), await this.sshClient.chmod(a, 488), {
+        history: o,
+        minioRelPath: a,
+        downloadedPl: O(t, e.arch)
+      };
+    } catch (i) {
+      const n = `SshPl.downloadBinariesAndUploadToServer: error ${i} occurred, state: ${JSON.stringify(o)}`;
+      throw this.logger.error(n), i;
+    }
+  }
+  /** 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) {
+    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++)
+      try {
+        a = await lt(
+          this.logger,
+          r,
+          o,
+          i,
+          e.arch,
+          e.platform
+        );
+        break;
+      } catch (m) {
+        if (await S(300), u == 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);
+    const l = await this.sshClient.exec(
+      `tar xvf ${n.remoteArchivePath} --directory=${n.remoteDir}`
+    );
+    if (l.stderr)
+      throw new Error(`downloadAndUntar: untar: stderr occurred: ${l.stderr}, stdout: ${l.stdout}`);
+    return n.plUntarDone = !0, n;
+  }
+  async needDownload(r, t) {
+    const e = L(r, t.arch), o = J(r, t.arch), i = O(r, t.arch);
+    return !await this.sshClient.checkFileExists(i) || !await this.sshClient.checkFileExists(o) || !await this.sshClient.checkFileExists(e);
+  }
+  async checkIsAliveWithInterval(r = 1e3, t = 15, e = !0) {
+    const o = t * r;
+    let i = 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.`);
+      n = await this.isAlive();
+    }
+  }
+  async getUserCredentials(r) {
+    const t = await this.sshClient.readFile(k(r));
+    return JSON.parse(t);
+  }
+  async fetchPorts(r, t) {
+    return {
+      grpc: {
+        local: await y(),
+        remote: await this.getFreePortForPlatformaOnServer(r, t)
+      },
+      monitoring: {
+        local: await y(),
+        remote: await this.getFreePortForPlatformaOnServer(r, t)
+      },
+      debug: {
+        local: await y(),
+        remote: await this.getFreePortForPlatformaOnServer(r, t)
+      },
+      minioPort: {
+        local: await y(),
+        remote: await this.getFreePortForPlatformaOnServer(r, t)
+      },
+      minioConsolePort: {
+        local: await y(),
+        remote: await this.getFreePortForPlatformaOnServer(r, t)
+      }
+    };
+  }
+  async getLocalFreePort() {
+    return new Promise((r) => {
+      const t = T.createServer();
+      t.listen(0, () => {
+        const e = t.address().port;
+        t.close((o) => r(e));
+      });
+    });
+  }
+  async getFreePortForPlatformaOnServer(r, t) {
+    const e = xt(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;
+  }
+  async getArch() {
+    const { stdout: r, stderr: t } = await this.sshClient.exec("uname -s && uname -m");
+    if (t)
+      throw new Error(`getArch: stderr is not empty: ${t}, stdout: ${r}`);
+    const e = r.split(`
+`);
+    return {
+      platform: e[0],
+      arch: e[1]
+    };
+  }
+  async getUserHomeDirectory() {
+    const { stdout: r, stderr: t } = await this.sshClient.exec("echo $HOME");
+    if (t) {
+      const e = `/home/${this.username}`;
+      return console.warn(`getUserHomeDirectory: stderr is not empty: ${t}, stdout: ${r}, will get a default home: ${e}`), e;
+    }
+    return r.trim();
+  }
+}
+export {
+  St as LocalConfigYaml,
+  Et as LocalPl,
+  F as SshClient,
+  W as SshPl,
+  b as getDefaultPlVersion,
+  Qt as localPlatformaInit
+};
+//# sourceMappingURL=index.mjs.map