ramm 0.0.62 → 0.0.64

package/dist/bun.sh

@@ -0,0 +1,23 @@
+#!/bin/bash
+
+if ! command -v unzip &> /dev/null; then
+  . /etc/os-release
+
+  if [[ "$ID_LIKE" == *"rhel"* ]]; then
+    sudo dnf install -y unzip
+  fi
+  
+  if [[ "$ID" == "ubuntu" ]]; then
+    sudo apt update
+    sudo apt install -y unzip
+  fi
+fi
+
+if ! command -v bun &> /dev/null; then
+    echo "Installing bun..."
+    
+    curl -fsSL https://bun.sh/install | bash
+    ln -s "$HOME/.bun/bin/bun" /usr/local/bin/bun
+else
+    echo "Already installed bun."
+fi

package/dist/ramm.js

@@ -0,0 +1,617 @@
+// @bun
+// src/base/base.ts
+var {spawn } = globalThis.Bun;
+
+// src/print.ts
+var printInternal = (left, right) => {
+  console.info(`\x1B[32m${left}:\x1B[0m \x1B[38;5;85m${right}\x1B[0m`);
+};
+var printCommand = (command) => {
+  printInternal("Command", command);
+};
+var printFunction = (func) => {
+  printInternal("Function", func);
+};
+var printBlock = (name) => {
+  console.info(`\x1B[34mBlock:\x1B[0m \x1B[38;5;81m${name}\x1B[0m`);
+};
+
+// src/context.ts
+class Context {
+  user;
+  domain;
+  userspace = false;
+  sudo = false;
+  sshKey;
+  params = {};
+  constructor({
+    user,
+    address,
+    userspace = false,
+    sudo = false,
+    sshKey
+  }) {
+    this.user = user;
+    this.domain = address;
+    this.sudo = sudo;
+    this.userspace = userspace;
+    this.sshKey = sshKey;
+  }
+  getAddress() {
+    return `${this.user}@${this.domain}`;
+  }
+}
+
+// src/base/tee.ts
+var tee = async (read, write, prefix) => {
+  const reader = read.getReader();
+  let leftover = "";
+  let output = "";
+  const decoder = new TextDecoder("utf-8");
+  while (true) {
+    const { value, done } = await reader.read();
+    if (done) {
+      if (leftover)
+        write(prefix + leftover + `
+`);
+      return output;
+    }
+    const decodedOutput = decoder.decode(value, { stream: true });
+    output += decodedOutput;
+    const lines = (leftover + decodedOutput).split(`
+`);
+    leftover = lines.pop() ?? "";
+    for (const line of lines) {
+      write(prefix + line + `
+`);
+    }
+  }
+};
+var teeStdout = (read, prefix) => {
+  return tee(read, (text) => process.stdout.write(text), prefix);
+};
+var teeStderr = (read, prefix) => {
+  return tee(read, (text) => process.stderr.write(text), prefix);
+};
+
+// src/base/base.ts
+var defaultContext = new Context({
+  user: "root",
+  address: "0.0.0.0",
+  userspace: false,
+  sudo: false
+});
+var execCommandRaw = async (command, { store = {}, signal, env, cwd, prefix = "" } = {}, ctx) => {
+  const finalCommand = ctx?.sudo ? `sudo ${command}` : command;
+  const spawnResult = spawn(["bash", "-c", finalCommand], {
+    stdin: "inherit",
+    stdout: "pipe",
+    stderr: "pipe",
+    signal,
+    cwd,
+    env
+  });
+  store.spawnResult = spawnResult;
+  const [stdout, stderr] = await Promise.all([
+    teeStdout(spawnResult.stdout, prefix),
+    teeStderr(spawnResult.stderr, prefix)
+  ]);
+  await spawnResult.exited;
+  return {
+    stderr,
+    stdout,
+    spawnResult
+  };
+};
+var execCommandMayError = async (command, props, context) => {
+  printCommand(command);
+  return execCommandRaw(command, props, context);
+};
+var execCommand = async (command, props, context) => {
+  const callSiteError = new Error(command);
+  const result = await execCommandMayError(command, props, context);
+  if (result.spawnResult.exitCode !== 0) {
+    console.error(`<${command}> exitCode: ${result.spawnResult.exitCode}`);
+    callSiteError.stack = callSiteError.stack?.split(`
+`).slice(1).join(`
+`);
+    throw callSiteError;
+  }
+  return result;
+};
+var copyFilesOverSsh = async (from, to, context) => {
+  const sshKeyPart = context.sshKey ? ` -e "ssh -i ${context.sshKey}"` : "";
+  await execCommand(`rsync -avz${sshKeyPart} ${from} ${context.getAddress()}:${to}`);
+};
+var execCommandOverSsh = async (command, context) => {
+  const sshKeyPart = context.sshKey ? ` -i ${context.sshKey}` : "";
+  const escapedCommand = command.replace(/'/g, "'\\''");
+  return await execCommand(`ssh${sshKeyPart} ${context.getAddress()} '${escapedCommand}'`);
+};
+// src/init.ts
+var installBunOverSsh = async (context) => {
+  const bunPath = new URL(import.meta.resolve("./bun.sh")).pathname;
+  await copyFilesOverSsh(bunPath, "./bun.sh", context);
+  await execCommandOverSsh("./bun.sh", context);
+};
+// src/packages.ts
+var dnfOs = ["rocky", "fedora", "alma"];
+var aptOs = ["ubuntu"];
+var getManagerByOs = (osName) => {
+  if (aptOs.includes(osName)) {
+    return "apt";
+  } else if (dnfOs.includes(osName)) {
+    return "dnf";
+  } else {
+    throw new Error(`Unsupported OS: ${osName}`);
+  }
+};
+var getManagerConfig = (manager, packageConfig) => {
+  if (packageConfig.managers && manager in packageConfig.managers) {
+    const managerEnt = packageConfig.managers[manager];
+    return managerEnt;
+  }
+  return {
+    name: packageConfig.name,
+    command: packageConfig.command
+  };
+};
+var getInstallCommand = (manager, config) => {
+  if (manager === "apt") {
+    return `apt install -y ${config.name}`;
+  } else if (manager === "dnf") {
+    return `dnf install -y ${config.name}`;
+  } else {
+    throw new Error("Unknow manager");
+  }
+};
+var packages = {
+  nftables: {
+    name: "nftables",
+    command: "nft"
+  },
+  podman: {
+    name: "podman",
+    command: "podman"
+  }
+};
+var installSystemPackage = async (packageEnt, context) => {
+  const finalPackageEnt = typeof packageEnt === "string" ? packages[packageEnt] : packageEnt;
+  if (!finalPackageEnt) {
+    const errorMessage = `No package ent for: ${packageEnt}`;
+    throw new Error(errorMessage);
+  }
+  const { stdout: osRaw } = await execCommand("cat /etc/os-release | grep ^ID= | cut -d'=' -f2", {}, context);
+  const osName = osRaw.trim().replace(/"/g, "");
+  const manager = getManagerByOs(osName);
+  const managerConfig = getManagerConfig(manager, finalPackageEnt);
+  const checkResult = await execCommandMayError(`command -v ${managerConfig.command}`, {}, context);
+  if (checkResult.spawnResult.exitCode === 0) {
+    return;
+  }
+  const installCommand = getInstallCommand(manager, managerConfig);
+  await execCommand(installCommand, {}, context);
+};
+
+// src/files.ts
+import { appendFile, exists } from "fs/promises";
+var {file, write } = globalThis.Bun;
+
+// src/path.ts
+import { homedir } from "os";
+import { join } from "path";
+function normalizePath(rawFilePath) {
+  let finalFilePath = rawFilePath.trim();
+  if (finalFilePath.startsWith("~/")) {
+    finalFilePath = join(homedir(), finalFilePath.slice(2));
+  }
+  return finalFilePath;
+}
+
+// src/files.ts
+var normalizeFileContent = (str) => {
+  if (str === "") {
+    return str;
+  }
+  if (str.at(-1) !== `
+`) {
+    return str + `
+`;
+  }
+  return str;
+};
+var createDir = async (str, context = defaultContext) => {
+  const dirname = str.split("/").slice(0, -1).join("/");
+  const exist = await exists(dirname);
+  if (exist) {
+    return;
+  }
+  await execCommand(`mkdir -p ${dirname}`, {}, context);
+};
+var checkStrInFile = async (filePath, str) => {
+  const file2 = Bun.file(filePath);
+  if (!await file2.exists()) {
+    return false;
+  }
+  const fileText = await file2.text();
+  if (fileText.includes(str)) {
+    return true;
+  }
+  return false;
+};
+var createFileIfNeed = async (rawFilePath, context = defaultContext) => {
+  const filePath = normalizePath(rawFilePath);
+  await createDir(filePath, context);
+  if (!await file(filePath).exists()) {
+    await execCommand(`touch ${filePath}`, {}, context);
+  }
+};
+var writeFileStrUniq = async (rawFilePath, str, context = defaultContext) => {
+  const filePath = normalizePath(rawFilePath);
+  await createFileIfNeed(filePath, context);
+  if (await checkStrInFile(filePath, str)) {
+    return;
+  }
+  await appendFile(filePath, normalizeFileContent(str));
+};
+var writeFile = async (pathToFile, str, context = defaultContext) => {
+  const normalizedPath = normalizePath(pathToFile);
+  await createFileIfNeed(normalizedPath, context);
+  const fileText = await file(normalizedPath).text();
+  if (fileText === str) {
+    return;
+  }
+  await write(normalizedPath, str);
+};
+
+// src/systemd.ts
+var systemctlWordLangth = "systemctl ".length;
+var formatUserspace = (command, context = defaultContext) => {
+  const userPart = context.userspace ? " --user " : "";
+  return "systemctl" + userPart + " " + command.slice(systemctlWordLangth);
+};
+var reloadSystemd = async (context = defaultContext) => {
+  await execCommand(formatUserspace("systemctl daemon-reload", context));
+};
+var startSystemdUnit = async (unitName, context = defaultContext) => {
+  await execCommand(formatUserspace(`systemctl start ${unitName}`, context));
+};
+var enableSystemdUnit = async (unitName, context = defaultContext) => {
+  await execCommand(formatUserspace(`systemctl enable ${unitName}`, context));
+};
+var restartSystemdUnit = async (name, context = defaultContext) => {
+  await execCommand(formatUserspace(`systemctl restart ${name}`, context));
+};
+var stopSystemdUnit = async (name, context = defaultContext) => {
+  await execCommand(formatUserspace(`systemctl stop ${name}`, context));
+};
+var checkSystemdUnit = async (serviceName, context = defaultContext) => {
+  const { spawnResult } = await execCommandMayError(formatUserspace(`systemctl is-active ${serviceName}`, context));
+  return spawnResult.exitCode === 0;
+};
+var createSystemdUnit = async (unitName, content, context = defaultContext) => {
+  const pathToSeviceTarget = getSystemdPathToUnit(unitName, context);
+  await writeFile(pathToSeviceTarget, content);
+  await reloadSystemd(context);
+};
+var getSystemdPathToUnit = (serviceName, context = defaultContext) => {
+  if (context.userspace) {
+    return `~/.config/systemd/user/${serviceName}`;
+  }
+  return `/etc/systemd/system/${serviceName}`;
+};
+var createSystemdService = async (serviceName, content, context = defaultContext) => {
+  await createSystemdUnit(serviceName, content, context);
+  await enableSystemdUnit(serviceName, context);
+  await startSystemdUnit(serviceName, context);
+};
+
+// src/nft.ts
+var createNftTable = ({
+  allowedIpV4,
+  allowedPorts = []
+}) => {
+  const nftTable = `table inet ramm {
+    set allowed_ipv4 {
+      type ipv4_addr
+      flags dynamic
+      elements = { ${allowedIpV4.join(`
+	`)} }
+    }
+
+    chain local_chain_base {
+      iif "lo" accept
+      ct state established,related accept
+      ip saddr @allowed_ipv4 tcp dport 22 accept
+      tcp dport 22 ct state new limit rate over 700/minute burst 5 packets drop
+      tcp dport 22 accept
+      ${allowedPorts.map((port) => {
+    return `tcp dport ${port} accept`;
+  }).join(`
+`)}
+    }
+
+    chain local_chain {
+      jump local_chain_base
+      drop
+    }
+
+    chain prerouting {
+      type filter hook prerouting priority mangle; policy accept;
+      fib daddr type local jump local_chain
+    }
+  }
+  `;
+  return nftTable;
+};
+var setupNftable = async ({
+  allowedIpV4,
+  allowedPorts,
+  context = defaultContext
+}) => {
+  await installSystemPackage("nftables", context);
+  const listTable = await execCommandMayError("nft list table inet ramm", {}, context);
+  if (listTable.spawnResult.exitCode === 0) {
+    await execCommand("nft delete table inet ramm", {}, context);
+  }
+  const nftTable = createNftTable({ allowedIpV4, allowedPorts });
+  await execCommand(`nft -f - <<EOF
+${nftTable}
+EOF`, {}, context);
+  await safeNftTable(context);
+};
+var safeNftTable = async (context = defaultContext) => {
+  await execCommand("nft list ruleset > /etc/nftables.conf", {}, context);
+  await execCommand("systemctl enable nftables", {}, context);
+};
+
+// src/podman.ts
+var installPodman = async (context = defaultContext) => {
+  const check = await execCommandMayError("command -v podman", {}, context);
+  if (check.spawnResult.exitCode !== 0) {
+    await installSystemPackage("podman", context);
+  }
+  await createNetwork(context);
+};
+var createNetwork = async (context = defaultContext) => {
+  const netwroks = await execCommand("podman network inspect $(podman network ls -q) -f '{{.NetworkInterface}}'", {}, context);
+  const podmanNetworks = await execCommand("podman network ls", {}, context);
+  if (podmanNetworks.stdout.includes("ramm")) {
+    return;
+  }
+  if (netwroks.stdout.includes("podman_ramm")) {
+    return;
+  }
+  await execCommand("podman network create --interface-name=podman_ramm ramm", {}, context);
+};
+var getCreateCommand = async (name, context = defaultContext) => {
+  const result = await execCommandMayError(`podman inspect --format '{{.Config.CreateCommand}}' ${name}`, {}, context);
+  const text = result.stdout.trim();
+  if (text.startsWith("[") && text.endsWith("]")) {
+    return text.slice(1, -1);
+  }
+  return text;
+};
+var loginPodman = async (address, login, password, context = defaultContext) => {
+  return await execCommand(`echo "${password}" | podman login --username "${login}" --password-stdin ${address}`, {}, context);
+};
+var createPodmanCommand = ({
+  name,
+  replace = true,
+  background = true,
+  networks = ["ramm"],
+  envs = [],
+  volumes = [],
+  command
+}) => {
+  const values = [];
+  values.push("podman", "run");
+  if (name) {
+    values.push(`--name ${name}`);
+  }
+  if (replace) {
+    values.push("--replace");
+  }
+  if (background) {
+    values.push("-d");
+  }
+  for (const network of networks) {
+    values.push(`--network ${network}`);
+  }
+  for (const env of envs) {
+    values.push(`-e ${env.name}=${env.value}`);
+  }
+  for (const volume of volumes) {
+    values.push(`-v ${volume.from}:${volume.to}`);
+  }
+  values.push(command);
+  const str = values.join(" ");
+  return str;
+};
+var runPodmanContainer = async (name, command, context = defaultContext) => {
+  if (await getCreateCommand(name, context) !== command) {
+    await execCommand(`podman rm -f ${name}`, {}, context);
+    await execCommand(command, {}, context);
+    return;
+  }
+  console.info("Podman container is already running");
+};
+var runPodmanContainerService = async (name, command, context = defaultContext) => {
+  const serviceName = `${name}.service`;
+  const filepath = getSystemdPathToUnit(serviceName);
+  if (await checkSystemdUnit(serviceName, context)) {
+    await stopSystemdUnit(serviceName, context);
+  }
+  await runPodmanContainer(name, command, context);
+  await execCommand(`podman generate systemd --name --new ${name} > ${filepath}`, {}, context);
+  await reloadSystemd(context);
+  await startSystemdUnit(serviceName, context);
+  await enableSystemdUnit(serviceName, context);
+};
+var addNftPodmanRule = async (context = defaultContext) => {
+  const podmanNetworksResult = await execCommand("podman network inspect $(podman network ls -q) -f '{{.NetworkInterface}}'", {}, context);
+  const podmanNetworks = podmanNetworksResult.stdout.trim().split(`
+`);
+  await execCommand(`nft add set inet ramm podman_interfaces '{ type ifname; flags dynamic; elements = { ${podmanNetworks.join(", ")} }; }'`, {}, context);
+  await execCommand("nft insert rule inet ramm prerouting iifname @podman_interfaces accept", {}, context);
+  await safeNftTable(context);
+};
+// src/ssh.ts
+var {file: file2 } = globalThis.Bun;
+var addKeyToHostConfig = async (pathToHost, address, pathToKey, context = defaultContext) => {
+  const text = `Host ${address}
+  IdentityFile ${pathToKey}
+`;
+  await writeFileStrUniq(pathToHost, text, context);
+};
+var getServerFingerprint = async (context) => {
+  const { stdout } = await execCommandOverSsh('ssh-keyscan -t ed25519 localhost | grep -v "^#"', context);
+  return stdout.replace("localhost", context.domain);
+};
+var saveSshFingerptint = async (filePath, context) => {
+  const normalizedPath = normalizePath(filePath);
+  const fingerprint = await getServerFingerprint(context);
+  await writeFile(normalizedPath, fingerprint, context);
+};
+async function createSshKey(filePath, comment, context = defaultContext) {
+  printFunction(`${createSshKey.name} ${filePath}`);
+  const normalizedPathToKey = normalizePath(filePath);
+  const name = normalizedPathToKey.split("/").at(-1);
+  const pathToKeyPub = `${normalizedPathToKey}.pub`;
+  const pathToDir = normalizedPathToKey.split("/").slice(0, -1).join("/");
+  const pathToKeyFile = file2(normalizedPathToKey);
+  const pathToKeyPubFile = file2(pathToKeyPub);
+  if (await pathToKeyFile.exists() && await pathToKeyPubFile.exists()) {
+    return await pathToKeyPubFile.text();
+  }
+  await execCommand(`mkdir -p ${pathToDir}`, {}, context);
+  await execCommand(`ssh-keygen -t ed25519 -f ${normalizedPathToKey} -N "" -C "${comment || name}"`, {}, context);
+  await execCommand(`chmod 600 ${normalizedPathToKey}`, {}, context);
+  const pubKey = await Bun.file(pathToKeyPub).text();
+  return pubKey;
+}
+var addSshKeyToAuthorizedOverSsh = async (pubKey, context) => {
+  printFunction(`${addSshKeyToAuthorizedOverSsh.name} ${pubKey}`);
+  const { stdout: keys } = await execCommandOverSsh("cat .ssh/authorized_keys", context);
+  if (keys.includes(pubKey)) {
+    return;
+  }
+  await execCommandOverSsh(`echo "${pubKey}" >> .ssh/authorized_keys`, context);
+};
+var createAndAddSshKey = async (filePath, comment, context) => {
+  const normalizedPath = normalizePath(filePath);
+  const pubKey = await createSshKey(normalizedPath, comment, context);
+  console.log(`Key is: ${pubKey}`);
+  await addSshKeyToAuthorizedOverSsh(pubKey, context);
+};
+var addSshKeyToUse = async ({
+  key,
+  fingerprint,
+  filePath,
+  server,
+  context = defaultContext
+}) => {
+  printFunction(`${addSshKeyToUse.name} ${filePath}`);
+  const normalizedFilePath = normalizePath(filePath);
+  await writeFile(normalizedFilePath, key, context);
+  await execCommand(`chmod 0600 ${normalizedFilePath}`, {}, context);
+  await writeFileStrUniq("~/.ssh/known_hosts", fingerprint, context);
+  await addKeyToHostConfig("~/.ssh/config", server, normalizedFilePath, context);
+};
+// src/cron.ts
+var createCron = async ({
+  time,
+  pathToFile,
+  context = defaultContext
+}) => {
+  const pathToFileNorm = normalizePath(pathToFile);
+  const constructedLine = `${time} ${pathToFileNorm}`;
+  const tempFile = `/tmp/ramm_cron`;
+  const { stdout: cronConfig } = await execCommandMayError("crontab -l", {}, context);
+  if (cronConfig.includes(constructedLine)) {
+    return;
+  }
+  let baseCronConfig = cronConfig;
+  if (cronConfig.includes(pathToFileNorm)) {
+    baseCronConfig = cronConfig.split(`
+`).filter((str) => !str.includes(pathToFileNorm)).join(`
+`);
+  }
+  const newCronConfig = normalizeFileContent(normalizeFileContent(baseCronConfig) + constructedLine);
+  await writeFile(tempFile, newCronConfig, context);
+  await execCommandMayError(`cat ${tempFile}`, {}, context);
+  await execCommandMayError(`crontab ${tempFile}`, {}, context);
+  await execCommandMayError(`rm ${tempFile}`, {}, context);
+};
+// src/build.ts
+var {build, file: file3 } = globalThis.Bun;
+var buildAndRunOverSsh = async ({
+  entrypoint,
+  context
+}) => {
+  const normalizedEntrypoint = normalizePath(entrypoint);
+  const distName = `ramm_dist`;
+  const distDir = `/tmp/${distName}`;
+  const outputs = await build({
+    outdir: distDir,
+    entrypoints: [normalizedEntrypoint],
+    target: "bun"
+  });
+  const pathToDistFile = outputs.outputs[0]?.path;
+  const relativePathToFile = pathToDistFile.slice(distDir.length + 1);
+  await copyFilesOverSsh(`${distDir}/`, distDir, context);
+  await execCommandOverSsh(`bun run ${distDir}/${relativePathToFile}`, context);
+  await execCommand(`rm -rf ${distDir}`, {}, context);
+};
+var pathToJson = "/tmp/ramm_json";
+var passVarsClient = async (data, context) => {
+  printFunction("passVarsClient");
+  const json = JSON.stringify(data);
+  await writeFile(pathToJson, json, context);
+  await copyFilesOverSsh(pathToJson, pathToJson, context);
+  await execCommand(`rm -rf ${pathToJson}`, {}, context);
+};
+var passVarsServer = async (context = defaultContext) => {
+  printFunction("passVarsServer");
+  const jsonData = await file3(pathToJson).json();
+  await execCommand(`rm -rf ${pathToJson}`, {}, context);
+  return jsonData;
+};
+export {
+  writeFileStrUniq,
+  writeFile,
+  startSystemdUnit,
+  setupNftable,
+  saveSshFingerptint,
+  runPodmanContainerService,
+  runPodmanContainer,
+  restartSystemdUnit,
+  reloadSystemd,
+  printBlock,
+  passVarsServer,
+  passVarsClient,
+  normalizePath,
+  normalizeFileContent,
+  loginPodman,
+  installSystemPackage,
+  installPodman,
+  installBunOverSsh,
+  getSystemdPathToUnit,
+  getServerFingerprint,
+  execCommandRaw,
+  execCommandOverSsh,
+  execCommandMayError,
+  execCommand,
+  enableSystemdUnit,
+  createSystemdUnit,
+  createSystemdService,
+  createPodmanCommand,
+  createCron,
+  createAndAddSshKey,
+  copyFilesOverSsh,
+  buildAndRunOverSsh,
+  addSshKeyToUse,
+  addNftPodmanRule,
+  addKeyToHostConfig,
+  Context
+};

package/dist/types/base/base.d.ts

@@ -0,0 +1,35 @@
+import { type Subprocess } from "bun";
+import { Context } from "../context.ts";
+export declare const defaultContext: Context;
+export type ExecCommandStore = {
+    spawnResult?: Subprocess<"inherit", "pipe", "pipe">;
+};
+type ExecProps = {
+    store?: ExecCommandStore;
+    env?: Record<string, string>;
+    cwd?: string;
+    prefix?: string;
+    signal?: AbortSignal;
+} | void;
+export declare const execCommandRaw: (command: string, { store, signal, env, cwd, prefix }?: ExecProps, ctx?: Context) => Promise<{
+    stderr: string;
+    stdout: string;
+    spawnResult: Subprocess<"inherit", "pipe", "pipe">;
+}>;
+export declare const execCommandMayError: (command: string, props: ExecProps, context?: Context) => Promise<{
+    stderr: string;
+    stdout: string;
+    spawnResult: Subprocess<"inherit", "pipe", "pipe">;
+}>;
+export declare const execCommand: (command: string, props: ExecProps, context?: Context) => Promise<{
+    stderr: string;
+    stdout: string;
+    spawnResult: Subprocess<"inherit", "pipe", "pipe">;
+}>;
+export declare const copyFilesOverSsh: (from: string, to: string, context: Context) => Promise<void>;
+export declare const execCommandOverSsh: (command: string, context: Context) => Promise<{
+    stderr: string;
+    stdout: string;
+    spawnResult: Subprocess<"inherit", "pipe", "pipe">;
+}>;
+export {};

package/dist/types/base/tee.d.ts

@@ -0,0 +1,2 @@
+export declare const teeStdout: (read: ReadableStream, prefix: string) => Promise<string>;
+export declare const teeStderr: (read: ReadableStream, prefix: string) => Promise<string>;

package/dist/types/build.d.ts

@@ -0,0 +1,7 @@
+import type { Context } from "./context.ts";
+export declare const buildAndRunOverSsh: ({ entrypoint, context, }: {
+    entrypoint: string;
+    context: Context;
+}) => Promise<void>;
+export declare const passVarsClient: (data: Record<string, any>, context: Context) => Promise<void>;
+export declare const passVarsServer: (context?: Context) => Promise<any>;

package/dist/types/context.d.ts

@@ -0,0 +1,16 @@
+export declare class Context {
+    user: string;
+    domain: string;
+    userspace: boolean;
+    sudo: boolean;
+    sshKey?: string;
+    params: Record<string, string>;
+    constructor({ user, address, userspace, sudo, sshKey, }: {
+        user: string;
+        address: string;
+        userspace?: boolean;
+        sudo?: boolean;
+        sshKey?: string;
+    });
+    getAddress(): string;
+}

package/dist/types/cron.d.ts

@@ -0,0 +1,6 @@
+import type { Context } from "./context.ts";
+export declare const createCron: ({ time, pathToFile, context, }: {
+    time: string;
+    pathToFile: string;
+    context?: Context;
+}) => Promise<void>;

package/dist/types/files.d.ts

@@ -0,0 +1,4 @@
+import type { Context } from "./context.ts";
+export declare const normalizeFileContent: (str: string) => string;
+export declare const writeFileStrUniq: (rawFilePath: string, str: string, context?: Context) => Promise<void>;
+export declare const writeFile: (pathToFile: string, str: string, context?: Context) => Promise<void>;

package/dist/types/init.d.ts

@@ -0,0 +1,2 @@
+import type { Context } from "./context.ts";
+export declare const installBunOverSsh: (context: Context) => Promise<void>;

package/dist/types/nft.d.ts

@@ -0,0 +1,8 @@
+import type { Context } from "./context.ts";
+export declare const localNftChainName = "local_chain";
+export declare const setupNftable: ({ allowedIpV4, allowedPorts, context, }: {
+    allowedIpV4: string[];
+    allowedPorts: string[];
+    context?: Context;
+}) => Promise<void>;
+export declare const safeNftTable: (context?: Context) => Promise<void>;

package/dist/types/packages.d.ts

@@ -0,0 +1,13 @@
+import type { Context } from "./context.ts";
+type Manager = "dnf" | "apt";
+type PackageConfig = {
+    name: string;
+    command: string;
+    managers?: Record<Manager, ManagerConfig>;
+};
+type ManagerConfig = {
+    name: string;
+    command: string;
+};
+export declare const installSystemPackage: (packageEnt: string | PackageConfig, context?: Context) => Promise<void>;
+export {};

package/dist/types/path.d.ts

@@ -0,0 +1 @@
+export declare function normalizePath(rawFilePath: string): string;

package/dist/types/podman.d.ts

@@ -0,0 +1,25 @@
+import type { Context } from "./context.ts";
+export declare const installPodman: (context?: Context) => Promise<void>;
+export declare const loginPodman: (address: string, login: string, password: string, context?: Context) => Promise<{
+    stderr: string;
+    stdout: string;
+    spawnResult: import("bun").Subprocess<"inherit", "pipe", "pipe">;
+}>;
+export declare const createPodmanCommand: ({ name, replace, background, networks, envs, volumes, command, }: {
+    name?: string;
+    replace?: boolean;
+    background?: boolean;
+    networks?: string[];
+    envs?: {
+        name: string;
+        value: string;
+    }[];
+    volumes?: {
+        from: string;
+        to: string;
+    }[];
+    command: string;
+}) => string;
+export declare const runPodmanContainer: (name: string, command: string, context?: Context) => Promise<void>;
+export declare const runPodmanContainerService: (name: string, command: string, context?: Context) => Promise<void>;
+export declare const addNftPodmanRule: (context?: Context) => Promise<void>;

package/dist/types/print.d.ts

@@ -0,0 +1,3 @@
+export declare const printCommand: (command: string) => void;
+export declare const printFunction: (func: string) => void;
+export declare const printBlock: (name: string) => void;

package/dist/types/ramm.d.ts

@@ -0,0 +1,13 @@
+export { execCommandOverSsh, execCommand, execCommandMayError, copyFilesOverSsh, execCommandRaw, } from "./base/base.ts";
+export { Context } from "./context.ts";
+export { installBunOverSsh } from "./init.ts";
+export { installPodman, runPodmanContainer, loginPodman, runPodmanContainerService, addNftPodmanRule, createPodmanCommand, } from "./podman.ts";
+export { startSystemdUnit, enableSystemdUnit, restartSystemdUnit, createSystemdService, getSystemdPathToUnit, createSystemdUnit, reloadSystemd, } from "./systemd.ts";
+export { installSystemPackage } from "./packages.ts";
+export { printBlock } from "./print.ts";
+export { setupNftable } from "./nft.ts";
+export { writeFileStrUniq, writeFile, normalizeFileContent, } from "./files.ts";
+export { createAndAddSshKey, getServerFingerprint, addKeyToHostConfig, addSshKeyToUse, saveSshFingerptint, } from "./ssh.ts";
+export { normalizePath } from "./path.ts";
+export { createCron } from "./cron.ts";
+export { buildAndRunOverSsh, passVarsClient, passVarsServer } from "./build.ts";

package/dist/types/ssh.d.ts

@@ -0,0 +1,12 @@
+import type { Context } from "./context.ts";
+export declare const addKeyToHostConfig: (pathToHost: string, address: string, pathToKey: string, context?: Context) => Promise<void>;
+export declare const getServerFingerprint: (context: Context) => Promise<string>;
+export declare const saveSshFingerptint: (filePath: string, context: Context) => Promise<void>;
+export declare const createAndAddSshKey: (filePath: string, comment: string, context: Context) => Promise<void>;
+export declare const addSshKeyToUse: ({ key, fingerprint, filePath, server, context, }: {
+    key: string;
+    fingerprint: string;
+    filePath: string;
+    server: string;
+    context?: Context;
+}) => Promise<void>;

package/dist/types/systemd.d.ts

@@ -0,0 +1,10 @@
+import { Context } from "./context.ts";
+export declare const reloadSystemd: (context?: Context) => Promise<void>;
+export declare const startSystemdUnit: (unitName: string, context?: Context) => Promise<void>;
+export declare const enableSystemdUnit: (unitName: string, context?: Context) => Promise<void>;
+export declare const restartSystemdUnit: (name: string, context?: Context) => Promise<void>;
+export declare const stopSystemdUnit: (name: string, context?: Context) => Promise<void>;
+export declare const checkSystemdUnit: (serviceName: string, context?: Context) => Promise<boolean>;
+export declare const createSystemdUnit: (unitName: string, content: string, context?: Context) => Promise<void>;
+export declare const getSystemdPathToUnit: (serviceName: string, context?: Context) => string;
+export declare const createSystemdService: (serviceName: string, content: string, context?: Context) => Promise<void>;

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "ramm",
   "type": "module",
-  "version": "0.0.62",
+  "version": "0.0.64",
   "scripts": {
-    "build": "bun build ./src/ramm.ts --target bun --outdir ./dist && cp ./src/bun.sh ./dist/bun.sh",
-    "types": "tsc --project tsconfig.types.json"
+    "build": "bun run build:js && bun run build:types",
+    "build:js": "bun build ./src/ramm.ts --target bun --outdir ./dist && cp ./src/bun.sh ./dist/bun.sh",
+    "build:types": "tsc --project tsconfig.types.json"
   },
   "main": "dist/ramm.js",
   "types": "dist/types/ramm.d.ts",