ramm 0.0.22 → 0.0.24

package/dist/ramm.js

@@ -1,16 +1,16 @@
 // @bun
-// src/base.ts
+// src/base/base.ts
 var {spawn } = globalThis.Bun;
 
 // src/debug.ts
 var debugInternal = (func, command) => {
   console.info(`>>>${func}<<< ${command}`);
 };
-var debugSilentCommand = (command) => {
-  debugInternal("\x1B[32mCommand (silent)\x1B[0m", `\x1B[38;5;85m${command}\x1B[0m`);
-};
 var debugCommand = (command) => {
-  debugInternal("\x1B[32mCommand\x1B[0m", `\x1B[38;5;85m${command}\x1B[0m`);
+  debugInternal(">>>\x1B[32mCommand\x1B[0m<<<", `\x1B[38;5;85m${command}\x1B[0m`);
+};
+var debugApiCall = (command) => {
+  debugInternal(">>>\x1B[32mapi command\x1B[0m<<<", `\x1B[38;5;85m${command}\x1B[0m`);
 };
 var debugBlock = (text) => {
   debugInternal("\x1B[34mBlock\x1B[0m", `\x1B[38;5;81m${text}\x1B[0m`);
@@ -42,13 +42,7 @@ class Context {
   }
 }
 
-// src/base.ts
-var defaultContext = new Context({
-  name: "root",
-  address: "0.0.0.0",
-  userspace: false,
-  sudo: false
-});
+// src/base/tee.ts
 var tee = async (read) => {
   const reader = read.getReader();
   let output = "";
@@ -75,19 +69,15 @@ var teeErr = async (read) => {
     process.stderr.write(value);
   }
 };
-var readStreamToStr = async (read) => {
-  const reader = read.getReader();
-  let output = "";
-  while (true) {
-    const { value, done: doneReading } = await reader.read();
-    if (doneReading) {
-      return output;
-    }
-    const decoder = new TextDecoder("utf-8");
-    output += decoder.decode(value);
-  }
-};
-var execCommand = async (command) => {
+
+// src/base/base.ts
+var defaultContext = new Context({
+  name: "root",
+  address: "0.0.0.0",
+  userspace: false,
+  sudo: false
+});
+var execCommandMayError = async (command) => {
   debugCommand(command);
   const result = spawn(["bash", "-c", command], {
     stdin: "inherit",
@@ -105,15 +95,14 @@ var execCommand = async (command) => {
     spawnResult: result
   };
 };
-var execCommandSilent = async (command) => {
-  debugSilentCommand(command);
-  const result = spawn(["bash", "-c", command]);
-  const output = await readStreamToStr(result.stdout);
-  await result.exited;
-  return {
-    output,
-    spawnResult: result
-  };
+var execCommand = async (command) => {
+  const result = await execCommandMayError(command);
+  if (result.spawnResult.exitCode !== 0) {
+    console.error(">>>Error<<<");
+    console.error("command:", command);
+    throw new Error(command);
+  }
+  return result;
 };
 var copyFilesBySsh = async (from, to, context) => {
   await execCommand(`rsync -avz ${from} ${context.getAddress()}:${to}`);
@@ -136,7 +125,7 @@ var {$ } = globalThis.Bun;
 var installSystemPackage = async (packageName) => {
   const osName = (await $`cat /etc/os-release | grep ^ID= | cut -d'=' -f2`.text()).trim();
   if (osName === "ubuntu") {
-    await execCommand(`apt-get install -y ${packageName}`);
+    await execCommandMayError(`apt-get install -y ${packageName}`);
   }
 };
 
@@ -162,7 +151,7 @@ var restartSystemdService = async (name, constext = defaultContext) => {
   await execCommand(formatUserspace(constext, `systemctl restart ${name}`));
 };
 var checkSystemdService = async (context, serviceName) => {
-  const { spawnResult } = await execCommand(formatUserspace(context, `systemctl is-active ${serviceName}`));
+  const { spawnResult } = await execCommandMayError(formatUserspace(context, `systemctl is-active ${serviceName}`));
   return spawnResult.exitCode === 0;
 };
 var createSystemdService = async (context, serviceName, pathToServiceFile) => {
@@ -191,6 +180,9 @@ var getCreateCommand = async (name) => {
   const podmanCreateCommand = await $2`podman inspect --format '{{.Config.CreateCommand}}' ${name}`.nothrow().quiet();
   return podmanCreateCommand.text().slice(0, -1).slice(1, -1) || "";
 };
+var loginPodman = async (address, login, password) => {
+  return await execCommand(`echo "${password}" | podman login --username "${login}" --password-stdin ${address}`);
+};
 var runPodmanContainer = async (name, command) => {
   if (await getCreateCommand(name) !== command) {
     await $2`podman rm -f ${name}`;
@@ -244,7 +236,7 @@ var createNftTable = (allowed_ssh_ipv4) => {
   return nftTable;
 };
 var setupNftable = async (allowedIpSsh) => {
-  const listTable = await execCommandSilent("nft list table inet ramm");
+  const listTable = await execCommand("nft list table inet ramm");
   if (listTable.spawnResult.exitCode === 0) {
     await execCommand("nft delete table inet ramm");
   }
@@ -284,6 +276,7 @@ var normalizeFileContent = (str) => {
 };
 var createDir = async (str) => {
   const dirname = str.split("/").slice(0, -1).join("/");
+  debugApiCall(`exists(${dirname})`);
   const exist = await exists(dirname);
   if (exist) {
     return;
@@ -292,9 +285,11 @@ var createDir = async (str) => {
 };
 var checkStrInFile = async (filePath, str) => {
   const file2 = Bun.file(filePath);
+  debugApiCall(`file(${filePath}).exists())`);
   if (!await file2.exists()) {
     return false;
   }
+  debugApiCall(`file(${filePath}).text()`);
   const fileText = await file2.text();
   if (fileText.includes(str)) {
     return true;
@@ -304,7 +299,8 @@ var checkStrInFile = async (filePath, str) => {
 var createFileIfNeed = async (rawFilePath) => {
   const filePath = normalizePath(rawFilePath);
   await createDir(filePath);
-  if (!await Bun.file(filePath).exists()) {
+  debugApiCall(`file(${filePath}).exists())`);
+  if (!await file(filePath).exists()) {
     await execCommand(`touch ${filePath}`);
   }
 };
@@ -314,24 +310,29 @@ var writeIfNew = async (rawFilePath, str) => {
   if (await checkStrInFile(filePath, str)) {
     return;
   }
+  debugApiCall(`appendFile(${filePath})`);
   await appendFile(filePath, normalizeFileContent(str));
 };
 var writeFile = async (pathToFile, str) => {
   const normalizedPath = normalizePath(pathToFile);
   await createFileIfNeed(normalizedPath);
+  debugApiCall(`write(${normalizedPath})`);
   await write(normalizedPath, str);
 };
 var writeFileIfNotMatch = async (pathToFile, str) => {
   const normalizedPath = normalizePath(pathToFile);
   await createFileIfNeed(normalizedPath);
+  debugApiCall(`file(${normalizedPath}).text()`);
   const fileText = await file(normalizedPath).text();
   if (fileText === str) {
     return;
   }
+  debugApiCall(`write(${normalizedPath})`);
   await write(normalizedPath, str);
 };
 // src/ssh.ts
 import { debug } from "console";
+var {file: file2 } = globalThis.Bun;
 var addKeyToHostConfig = async (pathToHost, address, pathToKey) => {
   const text = `Host ${address}
   IdentityFile ${pathToKey}
@@ -346,14 +347,17 @@ async function createSshKey(pathToKey, comment) {
   const name = pathToKey.split("/").at(-1);
   const pathToKeyPub = `${pathToKey}.pub`;
   const pathToDir = pathToKey.split("/").slice(0, -1).join("/");
-  const pathToKeyFile = Bun.file(pathToKey);
-  const pathToKeyPubFile = Bun.file(pathToKeyPub);
+  const pathToKeyFile = file2(pathToKey);
+  const pathToKeyPubFile = file2(pathToKeyPub);
+  debugApiCall(`file(${pathToKey}).exist()`);
+  debugApiCall(`file(${pathToKeyPub}).exist()`);
   if (await pathToKeyFile.exists() && await pathToKeyPubFile.exists()) {
     return await pathToKeyPubFile.text();
   }
   await execCommand(`mkdir -p ${pathToDir}`);
   await execCommand(`ssh-keygen -t ed25519 -f ${pathToKey} -N "" -C "${comment || name}"`);
   await execCommand(`chmod 600 ${pathToKey}`);
+  debugApiCall(`file(${pathToKeyPub}).text()`);
   const pubKey = await Bun.file(pathToKeyPub).text();
   return pubKey;
 }
@@ -376,8 +380,8 @@ var createCron = async ({
 }) => {
   const pathToFileNorm = normalizePath(pathToFile);
   const constructedLine = `${time} ${pathToFileNorm}`;
-  const tempFile = `/tmp/cron_${new Date().getTime().toString()}`;
-  const { output: cronConfig } = await execCommand("crontab -l");
+  const tempFile = `/tmp/ramm_cron}`;
+  const { output: cronConfig } = await execCommandMayError("crontab -l");
   let newCronConfig = cronConfig;
   if (cronConfig.includes(constructedLine)) {
     return;
@@ -389,12 +393,12 @@ var createCron = async ({
   }
   newCronConfig = normalizeFileContent(normalizeFileContent(cronConfig) + constructedLine);
   await writeFile(tempFile, newCronConfig);
-  await execCommand(`cat ${tempFile}`);
-  await execCommand(`crontab ${tempFile}`);
-  await execCommand(`rm ${tempFile}`);
+  await execCommandMayError(`cat ${tempFile}`);
+  await execCommandMayError(`crontab ${tempFile}`);
+  await execCommandMayError(`rm ${tempFile}`);
 };
 // src/build.ts
-var {build, file: file2 } = globalThis.Bun;
+var {build, file: file3 } = globalThis.Bun;
 var buildAndRunOverSsh = async ({
   entrypoint,
   context
@@ -413,15 +417,18 @@ var buildAndRunOverSsh = async ({
   await execBySsh(`bun run ${distDir}/${relativePathToFile}`, context);
   await execCommand(`rm -rf ${distDir}`);
 };
+var pathToJson = "/tmp/ramm_json";
 var passVarsClient = async (data, context) => {
   const json = JSON.stringify(data);
-  await writeFile("/tmp/ramm_json", json);
-  await copyFilesBySsh("/tmp/ramm_json", "/tmp/ramm_json", context);
-  await execCommand("rm -rf /tmp/ramm_json");
+  debugApiCall(`writeFile(${pathToJson})`);
+  await writeFile(pathToJson, json);
+  await copyFilesBySsh(pathToJson, pathToJson, context);
+  await execCommand(`rm -rf ${pathToJson}`);
 };
 var passVarsServer = async () => {
-  const jsonData = await file2("/tmp/ramm_json").json();
-  await execCommand("rm -rf /tmp/ramm_json");
+  debugApiCall(`file(${pathToJson}).json`);
+  const jsonData = await file3(pathToJson).json();
+  await execCommand(`rm -rf ${pathToJson}`);
   return jsonData;
 };
 export {
@@ -436,11 +443,12 @@ export {
   passVarsClient,
   normalizePath,
   normalizeFileContent,
+  loginPodman,
   installSystemPackage,
   installPodman,
   installBun,
   getServerFingerprintBySsh,
-  execCommand,
+  execCommandMayError as execCommand,
   execBySsh,
   debugBlock,
   createCron,

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

@@ -0,0 +1,18 @@
+import { Context } from "../context.ts";
+export declare const defaultContext: Context;
+export declare const execCommandMayError: (command: string) => Promise<{
+    outputErr: string;
+    output: string;
+    spawnResult: import("bun").Subprocess<"inherit", "pipe", "pipe">;
+}>;
+export declare const execCommand: (command: string) => Promise<{
+    outputErr: string;
+    output: string;
+    spawnResult: import("bun").Subprocess<"inherit", "pipe", "pipe">;
+}>;
+export declare const copyFilesBySsh: (from: string, to: string, context: Context) => Promise<void>;
+export declare const execBySsh: (command: string, context: Context) => Promise<{
+    outputErr: string;
+    output: string;
+    spawnResult: import("bun").Subprocess<"inherit", "pipe", "pipe">;
+}>;

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

@@ -0,0 +1,3 @@
+export declare const tee: (read: ReadableStream) => Promise<string>;
+export declare const teeErr: (read: ReadableStream) => Promise<string>;
+export declare const readStreamToStr: (read: ReadableStream) => Promise<string>;

package/dist/types/debug.d.ts

@@ -1,4 +1,4 @@
-export declare const debugSilentCommand: (command: string) => void;
 export declare const debugCommand: (command: string) => void;
+export declare const debugApiCall: (command: string) => void;
 export declare const debugBlock: (text: string) => void;
 export declare const debug: (text: string) => void;

package/dist/types/podman.d.ts

@@ -1,6 +1,11 @@
 import type { Context } from "./context.ts";
 export declare const installPodman: () => Promise<void>;
 export declare const getCreateCommand: (name: string) => Promise<string>;
+export declare const loginPodman: (address: string, login: string, password: string) => Promise<{
+    outputErr: string;
+    output: string;
+    spawnResult: import("bun").Subprocess<"inherit", "pipe", "pipe">;
+}>;
 export declare const runPodmanContainer: (name: string, command: string) => Promise<void>;
 export declare const runPodmanContainerService: (name: string, command: string, context?: Context) => Promise<void>;
 export declare const addNftPodmanRule: () => Promise<void>;

package/dist/types/ramm.d.ts

@@ -1,7 +1,7 @@
-export { execBySsh, execCommand, copyFilesBySsh } from "./base.ts";
+export { execBySsh, execCommandMayError as execCommand, copyFilesBySsh, } from "./base/base.ts";
 export { Context } from "./context.ts";
 export { installBun } from "./init.ts";
-export { installPodman, runPodmanContainer } from "./podman.ts";
+export { installPodman, runPodmanContainer, loginPodman } from "./podman.ts";
 export { runPodmanContainerService, addNftPodmanRule } from "./podman.ts";
 export { restartSystemdService } from "./systemd.ts";
 export { installSystemPackage } from "./packages.ts";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "ramm",
   "type": "module",
-  "version": "0.0.22",
+  "version": "0.0.24",
   "scripts": {
     "build": "bun build ./src/ramm.ts --target bun --outdir ./dist && cp ./src/bun.sh ./dist/bun.sh && bun run types",
     "types": "tsc --project tsconfig.types.json"