ramm 0.0.30 → 0.0.32

package/dist/ramm.js

@@ -118,10 +118,6 @@ var execCommand = async (command, props) => {
 var copyFilesBySsh = async (from, to, context) => {
   await execCommand(`rsync -avz ${from} ${context.getAddress()}:${to}`);
 };
-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}'`);
@@ -130,7 +126,7 @@ var execCommandOverSsh = async (command, context) => {
 var installBun = async (context) => {
   const bunPath = new URL(import.meta.resolve("./bun.sh")).pathname;
   await copyFilesBySsh(bunPath, "./bun.sh", context);
-  await execBySsh("./bun.sh", context);
+  await execCommandOverSsh("./bun.sh", context);
 };
 // src/podman.ts
 var {$: $2 } = globalThis.Bun;
@@ -348,7 +344,6 @@ var writeIfNewCompletely = async (pathToFile, str) => {
   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}
@@ -356,48 +351,57 @@ var addKeyToHostConfig = async (pathToHost, address, pathToKey) => {
 `;
   await writeIfNew(pathToHost, text);
 };
-var getServerFingerprintBySsh = async (context) => {
-  const { stdout } = await execBySsh('ssh-keyscan -t ed25519 localhost | grep -v "^#"', context);
+var getServerFingerprint = async (context) => {
+  const { stdout } = await execCommandOverSsh('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);
+var saveSshFingerptint = async (filePath, context) => {
+  const fingerprint = await getServerFingerprint(context);
+  await writeIfNewCompletely(filePath, fingerprint);
+};
+async function createSshKey(filePath, comment) {
+  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}`);
-  await execCommand(`ssh-keygen -t ed25519 -f ${pathToKey} -N "" -C "${comment || name}"`);
-  await execCommand(`chmod 600 ${pathToKey}`);
+  await execCommand(`ssh-keygen -t ed25519 -f ${normalizedPathToKey} -N "" -C "${comment || name}"`);
+  await execCommand(`chmod 600 ${normalizedPathToKey}`);
   const pubKey = await Bun.file(pathToKeyPub).text();
   return pubKey;
 }
-var addSshKeyToAuthorized = async (pubKey, context) => {
-  const { stdout: keys } = await execBySsh("cat .ssh/authorized_keys", context);
+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 execBySsh(`echo "${pubKey}" >> .ssh/authorized_keys`, context);
+  await execCommandOverSsh(`echo "${pubKey}" >> .ssh/authorized_keys`, context);
 };
-var createAndAddSshKey = async (pathToKey, comment, context) => {
-  const pubKey = await createSshKey(pathToKey, comment);
-  debug(`Key is: ${pubKey}`);
-  await addSshKeyToAuthorized(pubKey, context);
+var createAndAddSshKey = async (filePath, comment, context) => {
+  const normalizedPath = normalizePath(filePath);
+  const pubKey = await createSshKey(normalizedPath, comment);
+  console.log(`Key is: ${pubKey}`);
+  await addSshKeyToAuthorizedOverSsh(pubKey, context);
 };
-var setupSshKey = async ({
+var addSshKeyToUse = async ({
   key,
   fingerprint,
-  pathToFile,
+  filePath,
   server
 }) => {
-  await writeIfNewCompletely(pathToFile, key);
-  await execCommand(`chmod 0600 ${pathToFile}`);
+  printFunction(`${addSshKeyToUse.name} ${filePath}`);
+  const normalizedFilePath = normalizePath(filePath);
+  await writeIfNewCompletely(normalizedFilePath, key);
+  await execCommand(`chmod 0600 ${normalizedFilePath}`);
   await writeIfNew("~/.ssh/known_hosts", fingerprint);
-  await addKeyToHostConfig("~/.ssh/config", server, pathToFile);
+  await addKeyToHostConfig("~/.ssh/config", server, normalizedFilePath);
 };
 // src/cron.ts
 var createCron = async ({
@@ -440,7 +444,7 @@ var buildAndRunOverSsh = async ({
   const pathToDistFile = outputs.outputs[0]?.path;
   const relativePathToFile = pathToDistFile.slice(distDir.length + 1);
   await copyFilesBySsh(`${distDir}/`, distDir, context);
-  await execBySsh(`bun run ${distDir}/${relativePathToFile}`, context);
+  await execCommandOverSsh(`bun run ${distDir}/${relativePathToFile}`, context);
   await execCommand(`rm -rf ${distDir}`);
 };
 var pathToJson = "/tmp/ramm_json";
@@ -458,11 +462,11 @@ var passVarsServer = async () => {
   return jsonData;
 };
 export {
+  writeIfNewCompletely,
   writeIfNew,
-  writeIfNewCompletely as writeFileIfNotMatch,
   writeFile,
-  setupSshKey,
   setupNftable,
+  saveSshFingerptint,
   runPodmanContainerService,
   runPodmanContainer,
   restartSystemdService,
@@ -475,14 +479,16 @@ export {
   installSystemPackage,
   installPodman,
   installBun,
-  getServerFingerprintBySsh,
+  getServerFingerprint,
+  execCommandRaw,
   execCommandOverSsh,
-  execCommandMayError as execCommand,
-  execBySsh,
+  execCommandMayError,
+  execCommand,
   createCron,
   createAndAddSshKey,
   copyFilesBySsh,
   buildAndRunOverSsh,
+  addSshKeyToUse,
   addNftPodmanRule,
   addKeyToHostConfig,
   Context

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

@@ -27,11 +27,6 @@ export declare const execCommand: (command: string, props: ExecProps) => Promise
     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<{
-    stderr: string;
-    stdout: string;
-    spawnResult: Subprocess<"inherit", "pipe", "pipe">;
-}>;
 export declare const execCommandOverSsh: (command: string, context: Context) => Promise<{
     stderr: string;
     stdout: string;

package/dist/types/ramm.d.ts

@@ -1,4 +1,4 @@
-export { execBySsh, execCommandOverSsh, execCommandMayError as execCommand, copyFilesBySsh, } from "./base/base.ts";
+export { execCommandOverSsh, execCommand, execCommandMayError, copyFilesBySsh, execCommandRaw, } from "./base/base.ts";
 export { Context } from "./context.ts";
 export { installBun } from "./init.ts";
 export { installPodman, runPodmanContainer, loginPodman } from "./podman.ts";
@@ -7,8 +7,8 @@ export { restartSystemdService } from "./systemd.ts";
 export { installSystemPackage } from "./packages.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";
+export { writeIfNew, writeFile, writeIfNewCompletely, 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

@@ -1,10 +1,11 @@
 import type { Context } from "./context.ts";
 export declare const addKeyToHostConfig: (pathToHost: string, address: string, pathToKey: string) => Promise<void>;
-export declare const getServerFingerprintBySsh: (context: Context) => Promise<string>;
-export declare const createAndAddSshKey: (pathToKey: string, comment: string, context: Context) => Promise<void>;
-export declare const setupSshKey: ({ key, fingerprint, pathToFile, server, }: {
+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, }: {
     key: string;
     fingerprint: string;
-    pathToFile: string;
+    filePath: string;
     server: string;
 }) => Promise<void>;

package/package.json

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