feat: Added support for linux distros

Author: kevinwang5658

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "codify-plugin-lib",
-  "version": "1.0.182-beta57",
+  "version": "1.0.182-beta66",
   "description": "Library plugin library",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -22,7 +22,7 @@
     "ajv": "^8.12.0",
     "ajv-formats": "^2.1.1",
     "clean-deep": "^3.4.0",
-    "codify-schemas": "1.0.86-beta10",
+    "codify-schemas": "1.0.86-beta11",
     "lodash.isequal": "^4.5.0",
     "nanoid": "^5.0.9",
     "strip-ansi": "^7.1.0",

package.json

@@ -77,6 +77,7 @@ export class Plugin {
             type: r.typeId,
             sensitiveParameters,
             operatingSystems: r.settings.operatingSystems,
+            linuxDistros: r.settings.linuxDistros,
           }
         })
     }
@@ -124,6 +125,7 @@ export class Plugin {
         requiredParameters: requiredPropertyNames,
       },
       operatingSystems: resource.settings.operatingSystems,
+      linuxDistros: resource.settings.linuxDistros,
       sensitiveParameters,
       allowMultiple
     }

src/plugin/plugin.ts

@@ -1,5 +1,5 @@
 import { JSONSchemaType } from 'ajv';
-import { OS, StringIndexedObject } from 'codify-schemas';
+import { LinuxDistro, OS, StringIndexedObject } from 'codify-schemas';
 import { ZodObject, z } from 'zod';
 
 import { StatefulParameterController } from '../stateful-parameter/stateful-parameter-controller.js';
@@ -52,6 +52,8 @@ export class ParsedResourceSettings<T extends StringIndexedObject> implements Re
   transformation?: InputTransformation;
 
   operatingSystems!: Array<OS>;
+  linuxDistros?: Array<LinuxDistro>;
+
   isSensitive?: boolean;
 
   private settings: ResourceSettings<T>;

src/resource/parsed-resource-settings.ts

@@ -1,5 +1,5 @@
 import { JSONSchemaType } from 'ajv';
-import { OS, StringIndexedObject } from 'codify-schemas';
+import { LinuxDistro, OS, StringIndexedObject } from 'codify-schemas';
 import isObjectsEqual from 'lodash.isequal'
 import path from 'node:path';
 import { ZodObject } from 'zod';
@@ -35,6 +35,11 @@ export interface ResourceSettings<T extends StringIndexedObject> {
    */
   operatingSystems: Array<OS>;
 
+  /**
+   * List of supported linux distros
+   */
+  linuxDistros?: Array<LinuxDistro>;
+
   /**
    * Schema to validate user configs with. Must be in the format JSON Schema draft07
    */

src/resource/resource-settings.ts

@@ -1,8 +1,10 @@
-import { OS } from 'codify-schemas';
+import { LinuxDistro, OS } from 'codify-schemas';
+import * as fsSync from 'node:fs';
+import * as fs from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 
-import { getPty, SpawnStatus } from '../pty/index.js';
+import { SpawnStatus, getPty } from '../pty/index.js';
 
 export function isDebug(): boolean {
   return process.env.DEBUG != null && process.env.DEBUG.includes('codify'); // TODO: replace with debug library
@@ -175,6 +177,163 @@ export const Utils = {
     const lines = pathQuery.split(':');
     return lines.includes(directory);
   },
+
+  async assertBrewInstalled(): Promise<void> {
+    const $ = getPty();
+    const brewCheck = await $.spawnSafe('which brew', { interactive: true });
+    if (brewCheck.status === SpawnStatus.ERROR) {
+      throw new Error(
+        `Homebrew is not installed. Cannot install git-lfs without Homebrew installed.
+
+Brew can be installed using Codify:
+{
+  "type": "homebrew",
+}`
+      );
+    }
+  },
+
+  /**
+   * Installs a package via the system package manager. This will use Homebrew on macOS and apt on Ubuntu/Debian or dnf on Fedora.
+   * @param packageName
+   */
+  async installViaPkgMgr(packageName: string): Promise<void> {
+    const $ = getPty();
+
+    if (Utils.isMacOS()) {
+      await this.assertBrewInstalled();
+      await $.spawn(`brew install ${packageName}`, { interactive: true, env: { HOMEBREW_NO_AUTO_UPDATE: 1 } });
+    }
+
+    if (Utils.isLinux()) {
+      const isAptInstalled = await $.spawnSafe('which apt');
+      if (isAptInstalled.status === SpawnStatus.SUCCESS) {
+        await $.spawn('apt-get update', { requiresRoot: true });
+        const { status, data } = await $.spawnSafe(`apt-get -y install ${packageName}`, {
+          requiresRoot: true,
+          env: { DEBIAN_FRONTEND: 'noninteractive' }
+        });
+
+        if (status === SpawnStatus.ERROR && data.includes('E: dpkg was interrupted, you must manually run \'sudo dpkg --configure -a\' to correct the problem.')) {
+          await $.spawn('dpkg --configure -a', { requiresRoot: true });
+          await $.spawn(`apt-get -y install ${packageName}`, {
+            requiresRoot: true,
+            env: { DEBIAN_FRONTEND: 'noninteractive' }
+          });
+
+          return;
+        }
+
+        if (status === SpawnStatus.ERROR) {
+          throw new Error(`Failed to install package ${packageName} via apt: ${data}`);
+        }
+      }
+
+      const isDnfInstalled = await $.spawnSafe('which dnf');
+      if (isDnfInstalled.status === SpawnStatus.SUCCESS) {
+        await $.spawn('dnf update', { requiresRoot: true });
+        await $.spawn(`dnf install ${packageName} -y`, { requiresRoot: true });
+      }
+
+      const isYumInstalled = await $.spawnSafe('which yum');
+      if (isYumInstalled.status === SpawnStatus.SUCCESS) {
+        await $.spawn('yum update', { requiresRoot: true });
+        await $.spawn(`yum install ${packageName} -y`, { requiresRoot: true });
+      }
+
+      const isPacmanInstalled = await $.spawnSafe('which pacman');
+      if (isPacmanInstalled.status === SpawnStatus.SUCCESS) {
+        await $.spawn('pacman -Syu', { requiresRoot: true });
+        await $.spawn(`pacman -S ${packageName} --noconfirm`, { requiresRoot: true });
+      }
+
+    }
+  },
+
+  async uninstallViaPkgMgr(packageName: string): Promise<boolean> {
+    const $ = getPty();
+
+    if (Utils.isMacOS()) {
+      await this.assertBrewInstalled();
+      const { status } = await $.spawnSafe(`brew uninstall --zap ${packageName}`, {
+        interactive: true,
+        env: { HOMEBREW_NO_AUTO_UPDATE: 1 }
+      });
+      return status === SpawnStatus.SUCCESS;
+    }
+
+    if (Utils.isLinux()) {
+      const isAptInstalled = await $.spawnSafe('which apt');
+      if (isAptInstalled.status === SpawnStatus.SUCCESS) {
+        const { status } = await $.spawnSafe(`apt-get autoremove -y --purge ${packageName}`, {
+          requiresRoot: true,
+          env: { DEBIAN_FRONTEND: 'noninteractive' }
+        });
+        return status === SpawnStatus.SUCCESS;
+      }
+
+      const isDnfInstalled = await $.spawnSafe('which dnf');
+      if (isDnfInstalled.status === SpawnStatus.SUCCESS) {
+        const { status } = await $.spawnSafe(`dnf autoremove ${packageName} -y`, { requiresRoot: true });
+        return status === SpawnStatus.SUCCESS;
+      }
+
+      const isYumInstalled = await $.spawnSafe('which yum');
+      if (isYumInstalled.status === SpawnStatus.SUCCESS) {
+        const { status } = await $.spawnSafe(`yum autoremove ${packageName} -y`, { requiresRoot: true });
+        return status === SpawnStatus.SUCCESS;
+      }
+
+      return false;
+    }
+
+    return false;
+  },
+
+  async getLinuxDistro(): Promise<LinuxDistro | undefined> {
+    const osRelease = await fs.readFile('/etc/os-release', 'utf8');
+    const lines = osRelease.split('\n');
+    for (const line of lines) {
+      if (line.startsWith('ID=')) {
+        const distroId = line.slice(3).trim().replaceAll('"', '');
+        return Object.values(LinuxDistro).includes(distroId as LinuxDistro) ? distroId as LinuxDistro : undefined;
+      }
+    }
+
+    return undefined;
+  },
+
+  async isUbuntu(): Promise<boolean> {
+    return (await this.getLinuxDistro()) === LinuxDistro.UBUNTU;
+  },
+
+  async isDebian(): Promise<boolean> {
+    return (await this.getLinuxDistro()) === LinuxDistro.DEBIAN;
+  },
+
+  async isArch(): Promise<boolean> {
+    return (await this.getLinuxDistro()) === LinuxDistro.ARCH;
+  },
+
+  async isCentOS(): Promise<boolean> {
+    return (await this.getLinuxDistro()) === LinuxDistro.CENTOS;
+  },
+
+  async isFedora(): Promise<boolean> {
+    return (await this.getLinuxDistro()) === LinuxDistro.FEDORA;
+  },
+
+  async isRHEL(): Promise<boolean> {
+    return (await this.getLinuxDistro()) === LinuxDistro.RHEL;
+  },
+
+  isDebianBased(): boolean {
+    return fsSync.existsSync('/etc/debian_version');
+  },
+
+  isRedhatBased(): boolean {
+    return fsSync.existsSync('/etc/redhat-release');
+  }
 };