ramm 0.0.28 → 0.0.30

package/dist/ramm.js

@@ -2,18 +2,18 @@
 // src/base/base.ts
 var {spawn } = globalThis.Bun;
 
-// src/debug.ts
-var debugInternal = (func, command) => {
-  console.info(`>>>${func}<<< ${command}`);
+// src/print.ts
+var printInternal = (left, right) => {
+  console.info(`\x1B[32m${left}:\x1B[0m \x1B[38;5;85m${right}\x1B[0m`);
 };
-var debugCommand = (command) => {
-  debugInternal(">>>\x1B[32mCommand\x1B[0m<<<", `\x1B[38;5;85m${command}\x1B[0m`);
+var printCommand = (command) => {
+  printInternal("Command", command);
 };
-var debugApiCall = (command) => {
-  debugInternal(">>>\x1B[32mapi command\x1B[0m<<<", `\x1B[38;5;85m${command}\x1B[0m`);
+var printFunction = (func) => {
+  printInternal("Function", func);
 };
-var debugBlock = (text) => {
-  debugInternal("\x1B[34mBlock\x1B[0m", `\x1B[38;5;81m${text}\x1B[0m`);
+var printBlock = (name) => {
+  console.info(`\x1B[34mBlock:\x1B[0m \x1B[38;5;81m${name}\x1B[0m`);
 };
 
 // src/context.ts
@@ -43,32 +43,36 @@ class Context {
 }
 
 // src/base/tee.ts
-var tee = async (read) => {
+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: doneReading } = await reader.read();
-    if (doneReading) {
+    const { value, done } = await reader.read();
+    if (done) {
+      if (leftover)
+        write(prefix + leftover + `
+`);
       return output;
     }
-    const decoder = new TextDecoder("utf-8");
-    output += decoder.decode(value);
-    process.stdout.write(value);
-  }
-};
-var teeErr = async (read) => {
-  const reader = read.getReader();
-  let output = "";
-  while (true) {
-    const { value, done: doneReading } = await reader.read();
-    if (doneReading) {
-      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 + `
+`);
     }
-    const decoder = new TextDecoder("utf-8");
-    output += decoder.decode(value);
-    process.stderr.write(value);
   }
 };
+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({
@@ -77,29 +81,36 @@ var defaultContext = new Context({
   userspace: false,
   sudo: false
 });
-var execCommandMayError = async (command) => {
-  debugCommand(command);
-  const result = spawn(["bash", "-c", command], {
+var execCommandRaw = async (command, { store = {}, signal, env, cwd, prefix = "" } = {}) => {
+  const spawnResult = spawn(["bash", "-c", command], {
     stdin: "inherit",
     stdout: "pipe",
-    stderr: "pipe"
+    stderr: "pipe",
+    signal,
+    cwd,
+    env
   });
-  const [output, outputErr] = await Promise.all([
-    tee(result.stdout),
-    teeErr(result.stderr)
+  store.spawnResult = spawnResult;
+  const [stdout, stderr] = await Promise.all([
+    teeStdout(spawnResult.stdout, prefix),
+    teeStderr(spawnResult.stderr, prefix)
   ]);
-  await result.exited;
+  await spawnResult.exited;
   return {
-    outputErr,
-    output,
-    spawnResult: result
+    stderr,
+    stdout,
+    spawnResult
   };
 };
-var execCommand = async (command) => {
-  const result = await execCommandMayError(command);
+var execCommandMayError = async (command, props) => {
+  printCommand(command);
+  return execCommandRaw(command, props);
+};
+var execCommand = async (command, props) => {
+  const result = await execCommandMayError(command, props);
   if (result.spawnResult.exitCode !== 0) {
-    console.error(">>>Error<<<");
-    console.error("command:", command);
+    console.error(`Error exit code: ${result.spawnResult.exitCode}`);
+    console.error(`Command: ${command}`);
     throw new Error(command);
   }
   return result;
@@ -111,6 +122,10 @@ var execBySsh = async (command, context) => {
   const sshKeyPart = context.sshKey ? ` -i ${context.sshKey}` : "";
   return await execCommand(`ssh${sshKeyPart} ${context.getAddress()} '${command}'`);
 };
+var execCommandOverSsh = async (command, context) => {
+  const sshKeyPart = context.sshKey ? ` -i ${context.sshKey}` : "";
+  return await execCommand(`ssh${sshKeyPart} ${context.getAddress()} '${command}'`);
+};
 // src/init.ts
 var installBun = async (context) => {
   const bunPath = new URL(import.meta.resolve("./bun.sh")).pathname;
@@ -148,6 +163,7 @@ var stopSystemdService = async (constext, name) => {
   await execCommand(formatUserspace(constext, `systemctl stop ${name}`));
 };
 var restartSystemdService = async (name, constext = defaultContext) => {
+  printFunction(`restartSystemdService ${name}`);
   await execCommand(formatUserspace(constext, `systemctl restart ${name}`));
 };
 var checkSystemdService = async (context, serviceName) => {
@@ -155,6 +171,7 @@ var checkSystemdService = async (context, serviceName) => {
   return spawnResult.exitCode === 0;
 };
 var createSystemdService = async (context, serviceName, pathToServiceFile) => {
+  printFunction(`createSystemdService ${serviceName}`);
   const pathToSeviceTarget = getSystemdPathToService(context, serviceName);
   await execCommand(`cp -v ${pathToServiceFile} ${pathToSeviceTarget}`);
   await execCommand(formatUserspace(context, "systemctl daemon-reload"));
@@ -172,10 +189,10 @@ var installPodman = async () => {
 var createNetwork = async () => {
   const netwroks = await execCommand("podman network inspect $(podman network ls -q) -f '{{.NetworkInterface}}'");
   const podmanNetworks = await execCommand("podman network ls");
-  if (podmanNetworks.output.includes("ramm")) {
+  if (podmanNetworks.stdout.includes("ramm")) {
     return;
   }
-  if (netwroks.output.includes("podman_ramm")) {
+  if (netwroks.stdout.includes("podman_ramm")) {
     return;
   }
   await execCommand("podman network create --interface-name=podman_ramm ramm");
@@ -206,7 +223,7 @@ var runPodmanContainerService = async (name, command, context = defaultContext)
 };
 var addNftPodmanRule = async () => {
   const podmanNetworksResult = await execCommand("podman network inspect $(podman network ls -q) -f '{{.NetworkInterface}}'");
-  const podmanNetworks = podmanNetworksResult.output.trim().split(`
+  const podmanNetworks = podmanNetworksResult.stdout.trim().split(`
 `);
   await execCommand(`nft add set inet ramm podman_interfaces '{ type ifname; flags dynamic; elements = { ${podmanNetworks.join(", ")} }; }'`);
   await execCommand("nft insert rule inet ramm prerouting iifname @podman_interfaces accept");
@@ -284,7 +301,6 @@ 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;
@@ -293,11 +309,9 @@ 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;
@@ -307,7 +321,6 @@ var checkStrInFile = async (filePath, str) => {
 var createFileIfNeed = async (rawFilePath) => {
   const filePath = normalizePath(rawFilePath);
   await createDir(filePath);
-  debugApiCall(`file(${filePath}).exists())`);
   if (!await file(filePath).exists()) {
     await execCommand(`touch ${filePath}`);
   }
@@ -318,24 +331,20 @@ 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 writeIfNewCompletely = 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
@@ -348,29 +357,27 @@ var addKeyToHostConfig = async (pathToHost, address, pathToKey) => {
   await writeIfNew(pathToHost, text);
 };
 var getServerFingerprintBySsh = async (context) => {
-  const { output } = await execBySsh('ssh-keyscan -t ed25519 localhost | grep -v "^#"', context);
-  return output.replace("localhost", context.domain);
+  const { stdout } = await execBySsh('ssh-keyscan -t ed25519 localhost | grep -v "^#"', context);
+  return stdout.replace("localhost", context.domain);
 };
 async function createSshKey(pathToKey, comment) {
+  printFunction(createSshKey.name);
   const name = pathToKey.split("/").at(-1);
   const pathToKeyPub = `${pathToKey}.pub`;
   const pathToDir = pathToKey.split("/").slice(0, -1).join("/");
   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;
 }
 var addSshKeyToAuthorized = async (pubKey, context) => {
-  const { output: keys } = await execBySsh("cat .ssh/authorized_keys", context);
+  const { stdout: keys } = await execBySsh("cat .ssh/authorized_keys", context);
   if (keys.includes(pubKey)) {
     return;
   }
@@ -400,7 +407,7 @@ var createCron = async ({
   const pathToFileNorm = normalizePath(pathToFile);
   const constructedLine = `${time} ${pathToFileNorm}`;
   const tempFile = `/tmp/ramm_cron}`;
-  const { output: cronConfig } = await execCommandMayError("crontab -l");
+  const { stdout: cronConfig } = await execCommandMayError("crontab -l");
   let newCronConfig = cronConfig;
   if (cronConfig.includes(constructedLine)) {
     return;
@@ -438,14 +445,14 @@ var buildAndRunOverSsh = async ({
 };
 var pathToJson = "/tmp/ramm_json";
 var passVarsClient = async (data, context) => {
+  printFunction("passVarsClient");
   const json = JSON.stringify(data);
-  debugApiCall(`writeFile(${pathToJson})`);
   await writeFile(pathToJson, json);
   await copyFilesBySsh(pathToJson, pathToJson, context);
   await execCommand(`rm -rf ${pathToJson}`);
 };
 var passVarsServer = async () => {
-  debugApiCall(`file(${pathToJson}).json`);
+  printFunction("passVarsServer");
   const jsonData = await file3(pathToJson).json();
   await execCommand(`rm -rf ${pathToJson}`);
   return jsonData;
@@ -459,6 +466,7 @@ export {
   runPodmanContainerService,
   runPodmanContainer,
   restartSystemdService,
+  printBlock,
   passVarsServer,
   passVarsClient,
   normalizePath,
@@ -468,9 +476,9 @@ export {
   installPodman,
   installBun,
   getServerFingerprintBySsh,
+  execCommandOverSsh,
   execCommandMayError as execCommand,
   execBySsh,
-  debugBlock,
   createCron,
   createAndAddSshKey,
   copyFilesBySsh,

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

@@ -1,18 +1,40 @@
+import { type Subprocess } from "bun";
 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 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) => Promise<{
+    stderr: string;
+    stdout: string;
+    spawnResult: 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 execCommandMayError: (command: string, props: ExecProps) => Promise<{
+    stderr: string;
+    stdout: string;
+    spawnResult: Subprocess<"inherit", "pipe", "pipe">;
+}>;
+export declare const execCommand: (command: string, props: ExecProps) => Promise<{
+    stderr: string;
+    stdout: string;
+    spawnResult: 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">;
+    stderr: string;
+    stdout: string;
+    spawnResult: Subprocess<"inherit", "pipe", "pipe">;
+}>;
+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

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

package/dist/types/podman.d.ts

@@ -2,8 +2,8 @@ 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;
+    stderr: string;
+    stdout: string;
     spawnResult: import("bun").Subprocess<"inherit", "pipe", "pipe">;
 }>;
 export declare const runPodmanContainer: (name: string, command: string) => 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

@@ -1,11 +1,11 @@
-export { execBySsh, execCommandMayError as execCommand, copyFilesBySsh, } from "./base/base.ts";
+export { execBySsh, execCommandOverSsh, execCommandMayError as execCommand, copyFilesBySsh, } from "./base/base.ts";
 export { Context } from "./context.ts";
 export { installBun } from "./init.ts";
 export { installPodman, runPodmanContainer, loginPodman } from "./podman.ts";
 export { runPodmanContainerService, addNftPodmanRule } from "./podman.ts";
 export { restartSystemdService } from "./systemd.ts";
 export { installSystemPackage } from "./packages.ts";
-export { debugBlock } from "./debug.ts";
+export { printBlock } from "./print.ts";
 export { setupNftable } from "./nft.ts";
 export { writeIfNew, writeFile, writeIfNewCompletely as writeFileIfNotMatch, normalizeFileContent, } from "./files.ts";
 export { createAndAddSshKey, getServerFingerprintBySsh, addKeyToHostConfig, setupSshKey, } from "./ssh.ts";

package/package.json

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