ramm 0.0.4 → 0.0.5

package/dist/ramm.js

@@ -12,7 +12,7 @@ var debugSilentCommand = (command) => {
 var debugCommand = (command) => {
   debugInternal("\x1B[32mCommand\x1B[0m", `\x1B[38;5;85m${command}\x1B[0m`);
 };
-var debug = (text) => {
+var debugBlock = (text) => {
   debugInternal("\x1B[34mBlock\x1B[0m", `\x1B[38;5;81m${text}\x1B[0m`);
 };
 
@@ -22,16 +22,19 @@ class Context {
   domain;
   userspace;
   sudo;
+  sshKey;
   constructor({
     name,
     address,
     userspace = false,
-    sudo = false
+    sudo = false,
+    sshKey
   }) {
     this.name = name;
     this.domain = address;
     this.sudo = sudo;
     this.userspace = userspace;
+    this.sshKey = sshKey;
   }
   getAddress() {
     return `${this.name}@${this.domain}`;
@@ -94,17 +97,18 @@ var execCommandSilent = async (command) => {
     spawnResult: result
   };
 };
-var copyFiles = async (from, to, context) => {
+var copyFilesBySsh = async (from, to, context) => {
   await execCommand(`rsync -avz ${from} ${context.getAddress()}:${to}`);
 };
-var exec = async (command, context) => {
-  await execCommand(`ssh ${context.getAddress()} "${command}"`);
+var execBySsh = 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;
-  await copyFiles(bunPath, "./bun.sh", context);
-  await exec("./bun.sh", context);
+  await copyFilesBySsh(bunPath, "./bun.sh", context);
+  await execBySsh("./bun.sh", context);
 };
 // src/podman.ts
 var {$: $2 } = globalThis.Bun;
@@ -209,8 +213,37 @@ var addNftPodmanRule = async () => {
   const podmanNetworks = podmanNetworksResult.output.trim().split(`
 `);
   await execCommand(`nft add set inet ramm podman_interfaces '{ type ifname; flags dynamic; elements = { ${podmanNetworks.join(", ")} }; }'`);
-  await execCommand("nft add chain inet ramm forward '{ type filter hook input priority 0 ; }'");
-  await execCommand(`nft add rule inet ramm forward iifname @podman_interfaces jump ${localNftChainName}`);
+  await execCommand("nft add chain inet ramm forward '{ type filter hook forward priority 0 ; }'");
+  await execCommand(`nft add rule inet ramm forward iifname != @podman_interfaces jump ${localNftChainName}`);
+};
+// src/ssh.ts
+import { debug } from "console";
+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);
+  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}`);
+  const pubKey = await Bun.file(pathToKeyPub).text();
+  return pubKey;
+}
+var addSshKey = async (pubKey, context) => {
+  const { output: keys } = await execBySsh("cat .ssh/authorized_keys", context);
+  if (keys.includes(pubKey)) {
+    return;
+  }
+  await execBySsh(`echo "${pubKey}" >> .ssh/authorized_keys`, context);
+};
+var createAndAddSshKey = async (pathToKey, comment, context) => {
+  const pubKey = await createSshKey(pathToKey, comment);
+  debug(`Key is: ${pubKey}`);
+  await addSshKey(pubKey, context);
 };
 export {
   setupNftable,
@@ -220,9 +253,10 @@ export {
   installSystemPackage,
   installPodman,
   installBun,
-  exec,
-  debug,
-  copyFiles,
+  execBySsh,
+  debugBlock,
+  createAndAddSshKey,
+  copyFilesBySsh,
   addNftPodmanRule,
   Context
 };

package/dist/types/dist/ramm.d.ts

@@ -0,0 +1,30 @@
+export function setupNftable(allowedIpSsh: any): Promise<void>;
+export function runPodmanContainerService(name: any, command: any, context?: Context): Promise<void>;
+export function runPodmanContainer(name: any, command: any): Promise<void>;
+export function restartSystemdService(name: any, constext?: Context): Promise<void>;
+export function installSystemPackage(packageName: any): Promise<void>;
+export function installPodman(): Promise<void>;
+export function installBun(context: any): Promise<void>;
+export function execBySsh(command: any, context: any): Promise<{
+    output: string;
+    spawnResult: import("bun").Subprocess<"inherit", "pipe", "inherit">;
+}>;
+export function debugBlock(text: any): void;
+export function createAndAddSshKey(pathToKey: any, comment: any, context: any): Promise<void>;
+export function copyFilesBySsh(from: any, to: any, context: any): Promise<void>;
+export function addNftPodmanRule(): Promise<void>;
+export class Context {
+    constructor({ name, address, userspace, sudo, sshKey }: {
+        name: any;
+        address: any;
+        userspace?: boolean | undefined;
+        sudo?: boolean | undefined;
+        sshKey: any;
+    });
+    name: any;
+    domain: any;
+    userspace: boolean;
+    sudo: boolean;
+    sshKey: any;
+    getAddress(): string;
+}

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

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

package/dist/types/src/context.d.ts

@@ -0,0 +1,15 @@
+export declare class Context {
+    name: string;
+    domain: string;
+    userspace: boolean;
+    sudo: boolean;
+    sshKey?: string;
+    constructor({ name, address, userspace, sudo, sshKey, }: {
+        name: string;
+        address: string;
+        userspace?: boolean;
+        sudo?: boolean;
+        sshKey?: string;
+    });
+    getAddress(): string;
+}

package/dist/types/src/debug.d.ts

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

package/dist/types/src/init.d.ts

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

package/dist/types/src/nft.d.ts

@@ -0,0 +1,2 @@
+export declare const localNftChainName = "local_chain";
+export declare const setupNftable: (allowedIpSsh: string) => Promise<void>;

package/dist/types/src/packages.d.ts

@@ -0,0 +1 @@
+export declare const installSystemPackage: (packageName: string) => Promise<void>;

package/dist/types/src/podman.d.ts

@@ -0,0 +1,6 @@
+import type { Context } from "./context.ts";
+export declare const installPodman: () => Promise<void>;
+export declare const getCreateCommand: (name: string) => Promise<string>;
+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/src/ramm.d.ts

@@ -0,0 +1,10 @@
+export { execBySsh, copyFilesBySsh } from "./base.ts";
+export { Context } from "./context.ts";
+export { installBun } from "./init.ts";
+export { installPodman, runPodmanContainer } 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 { setupNftable } from "./nft.ts";
+export { createAndAddSshKey } from "./ssh.ts";

package/dist/types/src/ssh.d.ts

@@ -0,0 +1,2 @@
+import type { Context } from "../dist/ramm.js";
+export declare const createAndAddSshKey: (pathToKey: string, comment: string, context: Context) => Promise<void>;

package/dist/types/src/systemd.d.ts

@@ -0,0 +1,6 @@
+import { Context } from "./context.ts";
+export declare const getSysyemdServiceName: (name: string) => string;
+export declare const stopSystemdService: (constext: Context, name: string) => Promise<void>;
+export declare const restartSystemdService: (name: string, constext?: Context) => Promise<void>;
+export declare const checkSystemdService: (context: Context, serviceName: string) => Promise<boolean>;
+export declare const createSystemdService: (context: Context, serviceName: string, pathToServiceFile: string) => Promise<void>;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "ramm",
   "type": "module",
-  "version": "0.0.4",
+  "version": "0.0.5",
   "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"