ramm 0.0.53 → 0.0.56

package/dist/ramm.js

@@ -134,17 +134,61 @@ var {$: $2 } = globalThis.Bun;
 
 // src/packages.ts
 var {$ } = globalThis.Bun;
-var dnf_os = ["rocky", "fedora", "alma"];
-var installSystemPackage = async (packageName, context) => {
-  const osName = (await $`cat /etc/os-release | grep ^ID= | cut -d'=' -f2`.text()).trim();
-  const checkResult = await execCommandMayError(`which ${packageName}`, {}, context);
+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"
+  }
+};
+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 osName = (await $`cat /etc/os-release | grep ^ID= | cut -d'=' -f2`.text()).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);
   if (osName === "ubuntu") {
-    await execCommand(`apt-get install -y ${packageName}`, {}, context);
-  } else if (dnf_os.includes(osName)) {
-    await execCommand(`dnf install -y ${packageName}`, {}, context);
+    await execCommand(`apt-get install -y ${managerConfig.name}`, {}, context);
+  } else if (dnfOs.includes(osName)) {
+    await execCommand(`dnf install -y ${managerConfig.name}`, {}, context);
   } else {
     throw new Error(`Unsupported OS: ${osName}`);
   }

package/dist/types/packages.d.ts

@@ -1,2 +1,13 @@
 import type { Context } from "./context.ts";
-export declare const installSystemPackage: (packageName: string, context?: Context) => Promise<void>;
+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/package.json

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