@codifycli/plugin-core 1.0.0-beta1

package/src/utils/file-utils.ts

@@ -0,0 +1,231 @@
+import * as fsSync from 'node:fs';
+import * as fs from 'node:fs/promises';
+import path from 'node:path';
+import { Readable } from 'node:stream';
+import { finished } from 'node:stream/promises';
+
+import { Utils } from './index.js';
+
+const SPACE_REGEX = /^\s*$/
+
+export class FileUtils {
+  static async downloadFile(url: string, destination: string): Promise<void> {
+    console.log(`Downloading file from ${url} to ${destination}`);
+    const { body } = await fetch(url)
+
+    const dirname = path.dirname(destination);
+    if (!await fs.stat(dirname).then((s) => s.isDirectory()).catch(() => false)) {
+      await fs.mkdir(dirname, { recursive: true });
+    }
+
+    const ws = fsSync.createWriteStream(destination)
+    // Different type definitions here for readable stream (NodeJS vs DOM). Small hack to fix that
+    await finished(Readable.fromWeb(body as never).pipe(ws));
+
+    console.log(`Finished downloading to ${destination}`);
+  }
+
+  static async addToShellRc(line: string): Promise<void> {
+    const lineToInsert = addLeadingSpacer(
+      addTrailingSpacer(line)
+    );
+
+    await fs.appendFile(Utils.getPrimaryShellRc(), lineToInsert)
+
+    function addLeadingSpacer(line: string): string {
+      return line.startsWith('\n')
+        ? line
+        : '\n' + line;
+    }
+
+    function addTrailingSpacer(line: string): string {
+      return line.endsWith('\n')
+        ? line
+        : line + '\n';
+    }
+  }
+
+  static async addAllToShellRc(lines: string[]): Promise<void> {
+    const formattedLines = '\n' + lines.join('\n') + '\n';
+    const shellRc = Utils.getPrimaryShellRc();
+
+    console.log(`Adding to ${path.basename(shellRc)}:
+${lines.join('\n')}`)
+
+    await fs.appendFile(shellRc, formattedLines)
+  }
+
+  /**
+   * This method adds a directory path to the shell rc file if it doesn't already exist.
+   *
+   * @param value - The directory path to add.
+   * @param prepend - Whether to prepend the path to the existing PATH variable.
+   */
+  static async addPathToShellRc(value: string, prepend: boolean): Promise<void> {
+    if (await Utils.isDirectoryOnPath(value)) {
+      return;
+    }
+
+    const shellRc = Utils.getPrimaryShellRc();
+    console.log(`Saving path: ${value} to ${shellRc}`);
+
+    if (prepend) {
+      await fs.appendFile(shellRc, `\nexport PATH=$PATH:${value};`, { encoding: 'utf8' });
+      return;
+    }
+
+    await fs.appendFile(shellRc, `\nexport PATH=${value}:$PATH;`, { encoding: 'utf8' });
+  }
+
+  static async removeFromFile(filePath: string, search: string): Promise<void> {
+    const contents = await fs.readFile(filePath, 'utf8');
+    const newContents = contents.replaceAll(search, '');
+
+    await fs.writeFile(filePath, newContents, 'utf8');
+  }
+
+  static async removeLineFromFile(filePath: string, search: RegExp | string): Promise<void> {
+    const file = await fs.readFile(filePath, 'utf8')
+    const lines = file.split('\n');
+
+    let searchRegex;
+    let searchString;
+
+    if (typeof search === 'object') {
+      const startRegex = /^([\t ]*)?/;
+      const endRegex = /([\t ]*)?/;
+
+      // Augment regex with spaces criteria to make sure this function is not deleting lines that are comments or has other content.
+      searchRegex = search
+        ? new RegExp(
+          startRegex.source + search.source + endRegex.source,
+          search.flags
+        )
+        : search;
+    }
+
+    if (typeof search === 'string') {
+      searchString = search;
+    }
+
+    for (let counter = lines.length; counter >= 0; counter--) {
+      if (!lines[counter]) {
+        continue;
+      }
+
+      if (searchString && lines[counter].includes(searchString)) {
+        lines.splice(counter, 1);
+        continue;
+      }
+
+      if (searchRegex && lines[counter].search(searchRegex) !== -1) {
+        lines.splice(counter, 1);
+      }
+    }
+
+    await fs.writeFile(filePath, lines.join('\n'));
+    console.log(`Removed line: ${search} from ${filePath}`)
+  }
+
+  static async removeLineFromShellRc(search: RegExp | string): Promise<void> {
+    return FileUtils.removeLineFromFile(Utils.getPrimaryShellRc(), search);
+  }
+
+  static async removeAllLinesFromShellRc(searches: Array<RegExp | string>): Promise<void> {
+    for (const search of searches) {
+      await FileUtils.removeLineFromFile(Utils.getPrimaryShellRc(), search);
+    }
+  }
+
+  // Append the string to the end of a file ensuring at least 1 lines of space between.
+  // Ex result:
+  // something something;
+  //
+  // newline;
+  static appendToFileWithSpacing(file: string, textToInsert: string): string {
+    const lines = file.trimEnd().split(/\n/);
+    if (lines.length === 0) {
+      return textToInsert;
+    }
+
+    const endingNewLines = FileUtils.calculateEndingNewLines(lines);
+    const numNewLines = endingNewLines === -1
+      ? 0
+      : Math.max(0, 2 - endingNewLines);
+    return lines.join('\n') + '\n'.repeat(numNewLines) + textToInsert
+  }
+
+  static async dirExists(path: string): Promise<boolean> {
+    let stat;
+    try {
+      stat = await fs.stat(path);
+      return stat.isDirectory();
+    } catch {
+      return false;
+    }
+  }
+
+  static async fileExists(path: string): Promise<boolean> {
+    let stat;
+    try {
+      stat = await fs.stat(path);
+      return stat.isFile();
+    } catch {
+      return false;
+    }
+  }
+
+  static async exists(path: string): Promise<boolean> {
+    try {
+      await fs.stat(path);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  static async checkDirExistsOrThrowIfFile(path: string): Promise<boolean> {
+    let stat;
+    try {
+      stat = await fs.stat(path);
+    } catch {
+      return false;
+    }
+
+    if (stat.isDirectory()) {
+      return true;
+    }
+
+    throw new Error(`Directory ${path} already exists and is a file`);
+  }
+
+  static async createDirIfNotExists(path: string): Promise<void> {
+    if (!fsSync.existsSync(path)) {
+      await fs.mkdir(path, { recursive: true });
+    }
+  }
+
+  // This is overly complicated but it can be used to insert into any
+  // position in the future
+  private static calculateEndingNewLines(lines: string[]): number {
+    let counter = 0;
+    while (true) {
+      const line = lines.at(-counter - 1);
+
+      if (!line) {
+        return -1
+      }
+
+      if (!SPACE_REGEX.test(line)) {
+        return counter;
+      }
+
+      counter++;
+
+      // Short circuit here because we don't need to check over 2;
+      if (counter > 2) {
+        return counter;
+      }
+    }
+  }
+}

package/src/utils/functions.ts

@@ -0,0 +1,103 @@
+import { ResourceConfig, StringIndexedObject } from 'codify-schemas';
+import os from 'node:os';
+import path from 'node:path';
+
+export function splitUserConfig<T extends StringIndexedObject>(
+  config: ResourceConfig & T
+): { parameters: T; coreParameters: ResourceConfig } {
+  const coreParameters = {
+    type: config.type,
+    ...(config.name ? { name: config.name } : {}),
+    ...(config.dependsOn ? { dependsOn: config.dependsOn } : {}),
+    ...(config.os ? { os: config.os } : {}),
+  };
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  const { type, name, dependsOn, os, ...parameters } = config;
+
+  return {
+    parameters: parameters as T,
+    coreParameters,
+  };
+}
+
+export function setsEqual(set1: Set<unknown>, set2: Set<unknown>): boolean {
+  return set1.size === set2.size && [...set1].every((v) => set2.has(v));
+}
+
+const homeDirectory = os.homedir();
+
+export function untildify(pathWithTilde: string) {
+  return homeDirectory ? pathWithTilde.replace(/^~(?=$|\/|\\)/, homeDirectory) : pathWithTilde;
+}
+
+export function tildify(pathWithTilde: string) {
+  return homeDirectory ? pathWithTilde.replace(homeDirectory, '~') : pathWithTilde;
+}
+
+export function resolvePathWithVariables(pathWithVariables: string) {
+  return pathWithVariables.replace(/\$([A-Z_]+[A-Z0-9_]*)|\${([A-Z0-9_]*)}/ig, (_, a, b) => process.env[a || b]!)
+}
+
+export function addVariablesToPath(pathWithoutVariables: string) {
+  let result = pathWithoutVariables;
+  for (const [key, value] of Object.entries(process.env)) {
+    if (!value || !path.isAbsolute(value) || value === '/' || key === 'HOME' || key === 'PATH' || key === 'SHELL' || key === 'PWD') {
+      continue;
+    }
+
+    result = result.replaceAll(value, `$${key}`)
+  }
+
+  return result;
+}
+
+export function unhome(pathWithHome: string): string {
+  return pathWithHome.includes('$HOME') ? pathWithHome.replaceAll('$HOME', os.homedir()) : pathWithHome;
+}
+
+export function areArraysEqual(
+  isElementEqual: ((desired: unknown, current: unknown) => boolean) | undefined,
+  desired: unknown,
+  current: unknown
+): boolean {
+  if (!desired || !current) {
+    return false;
+  }
+
+  if (!Array.isArray(desired) || !Array.isArray(current)) {
+    throw new Error(`A non-array value:
+          
+Desired: ${JSON.stringify(desired, null, 2)}
+
+Current: ${JSON.stringify(desired, null, 2)}
+
+Was provided even though type array was specified.
+`)
+  }
+
+  if (desired.length !== current.length) {
+    return false;
+  }
+
+  const desiredCopy = [...desired];
+  const currentCopy = [...current];
+
+  // Algorithm for to check equality between two un-ordered; un-hashable arrays using
+  // an isElementEqual method. Time: O(n^2)
+  for (let counter = desiredCopy.length - 1; counter >= 0; counter--) {
+    const idx = currentCopy.findIndex((e2) => (
+      isElementEqual
+      ?? ((a, b) => a === b))(desiredCopy[counter], e2
+    ))
+
+    if (idx === -1) {
+      return false;
+    }
+
+    desiredCopy.splice(counter, 1)
+    currentCopy.splice(idx, 1)
+  }
+
+  return currentCopy.length === 0;
+}

package/src/utils/index.ts

@@ -0,0 +1,340 @@
+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 { 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
+}
+
+export enum Shell {
+  ZSH = 'zsh',
+  BASH = 'bash',
+  SH = 'sh',
+  KSH = 'ksh',
+  CSH = 'csh',
+  FISH = 'fish',
+}
+
+export interface SystemInfo {
+  os: OS;
+  shell: Shell;
+}
+
+export const Utils = {
+  getUser(): string {
+    return os.userInfo().username;
+  },
+
+  getSystemInfo() {
+    return {
+      os: os.type(),
+      shell: this.getShell(),
+    }
+  },
+
+  isMacOS(): boolean {
+    return os.platform() === 'darwin';
+  },
+
+  isLinux(): boolean {
+    return os.platform() === 'linux';
+  },
+
+  async isArmArch(): Promise<boolean> {
+    const $ = getPty();
+    if (!Utils.isMacOS()) {
+      // On Linux, check uname -m
+      const query = await $.spawn('uname -m');
+      return query.data.trim() === 'aarch64' || query.data.trim() === 'arm64';
+    }
+
+    const query = await $.spawn('sysctl -n machdep.cpu.brand_string');
+    return /M(\d)/.test(query.data);
+  },
+
+  async isHomebrewInstalled(): Promise<boolean> {
+    const $ = getPty();
+    const query = await $.spawnSafe('which brew', { interactive: true });
+    return query.status === SpawnStatus.SUCCESS;
+  },
+
+  async isRosetta2Installed(): Promise<boolean> {
+    if (!Utils.isMacOS()) {
+      return false;
+    }
+
+    const $ = getPty();
+    const query = await $.spawnSafe('arch -x86_64 /usr/bin/true 2> /dev/null', { interactive: true });
+    return query.status === SpawnStatus.SUCCESS;
+  },
+
+  getShell(): Shell | undefined {
+    const shell = process.env.SHELL || '';
+
+    if (shell.endsWith('bash')) {
+      return Shell.BASH
+    }
+
+    if (shell.endsWith('zsh')) {
+      return Shell.ZSH
+    }
+
+    if (shell.endsWith('sh')) {
+      return Shell.SH
+    }
+
+    if (shell.endsWith('csh')) {
+      return Shell.CSH
+    }
+
+    if (shell.endsWith('ksh')) {
+      return Shell.KSH
+    }
+
+    if (shell.endsWith('fish')) {
+      return Shell.FISH
+    }
+
+    return undefined;
+  },
+
+
+  getPrimaryShellRc(): string {
+    return this.getShellRcFiles()[0];
+  },
+
+  getShellRcFiles(): string[] {
+    const shell = process.env.SHELL || '';
+    const homeDir = os.homedir();
+
+    if (shell.endsWith('bash')) {
+      // Linux typically uses .bashrc, macOS uses .bash_profile
+      if (Utils.isLinux()) {
+        return [
+          path.join(homeDir, '.bashrc'),
+          path.join(homeDir, '.bash_profile'),
+          path.join(homeDir, '.profile'),
+        ];
+      }
+
+      return [
+        path.join(homeDir, '.bash_profile'),
+        path.join(homeDir, '.bashrc'),
+        path.join(homeDir, '.profile'),
+      ];
+    }
+
+    if (shell.endsWith('zsh')) {
+      return [
+        path.join(homeDir, '.zshrc'),
+        path.join(homeDir, '.zprofile'),
+        path.join(homeDir, '.zshenv'),
+      ];
+    }
+
+    if (shell.endsWith('sh')) {
+      return [
+        path.join(homeDir, '.profile'),
+      ]
+    }
+
+    if (shell.endsWith('ksh')) {
+      return [
+        path.join(homeDir, '.profile'),
+        path.join(homeDir, '.kshrc'),
+      ]
+    }
+
+    if (shell.endsWith('csh')) {
+      return [
+        path.join(homeDir, '.cshrc'),
+        path.join(homeDir, '.login'),
+        path.join(homeDir, '.logout'),
+      ]
+    }
+
+    if (shell.endsWith('fish')) {
+      return [
+        path.join(homeDir, '.config/fish/config.fish'),
+      ]
+    }
+
+    // Default to bash-style files
+    return [
+      path.join(homeDir, '.bashrc'),
+      path.join(homeDir, '.bash_profile'),
+      path.join(homeDir, '.profile'),
+    ];
+  },
+
+  async isDirectoryOnPath(directory: string): Promise<boolean> {
+    const $ = getPty();
+    const { data: pathQuery } = await $.spawn('echo $PATH', { interactive: true });
+    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', NEEDRESTART_MODE: 'a' }
+        });
+
+        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', NEEDRESTART_MODE: 'a' }
+          });
+
+          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', NEEDRESTART_MODE: 'a' }
+        });
+        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');
+  }
+};
+
+
+