codify-plugin-lib 1.0.182-beta4 → 1.0.182-beta40

package/src/resource/resource-settings.ts

@@ -2,6 +2,7 @@ import { JSONSchemaType } from 'ajv';
 import { OS, StringIndexedObject } from 'codify-schemas';
 import isObjectsEqual from 'lodash.isequal'
 import path from 'node:path';
+import { ZodObject } from 'zod';
 
 import { ArrayStatefulParameter, StatefulParameter } from '../stateful-parameter/stateful-parameter.js';
 import {
@@ -11,6 +12,7 @@ import {
   tildify,
   untildify
 } from '../utils/functions.js';
+import { ParsedResourceSettings } from './parsed-resource-settings.js';
 import { RefreshContext } from './resource.js';
 
 export interface InputTransformation {
@@ -36,7 +38,7 @@ export interface ResourceSettings<T extends StringIndexedObject> {
   /**
    * Schema to validate user configs with. Must be in the format JSON Schema draft07
    */
-  schema?: Partial<JSONSchemaType<T | any>>;
+  schema?: Partial<JSONSchemaType<T | any>> | ZodObject;
 
   /**
    * Mark the resource as sensitive. Defaults to false. This prevents the resource from automatically being imported by init and import.
@@ -44,6 +46,11 @@ export interface ResourceSettings<T extends StringIndexedObject> {
    */
   isSensitive?: boolean;
 
+  /**
+   * An optional description of the resource. This does not affect the behavior of the resource.
+   */
+  description?: string;
+
   /**
    * Allow multiple of the same resource to unique. Set truthy if
    * multiples are allowed, for example for applications, there can be multiple copy of the same application installed
@@ -349,7 +356,7 @@ export interface StatefulParameterSetting extends DefaultParameterSetting {
 
 const ParameterEqualsDefaults: Partial<Record<ParameterSettingType, (a: unknown, b: unknown) => boolean>> = {
   'boolean': (a: unknown, b: unknown) => Boolean(a) === Boolean(b),
-  'directory': (a: unknown, b: unknown) => {
+  'directory'(a: unknown, b: unknown) {
     let transformedA = resolvePathWithVariables(untildify(String(a)))
     let transformedB = resolvePathWithVariables(untildify(String(b)))
 
@@ -430,7 +437,7 @@ export function resolveFnFromEqualsFnOrString(
 const ParameterTransformationDefaults: Partial<Record<ParameterSettingType, InputTransformation>> = {
   'directory': {
     to: (a: unknown) => resolvePathWithVariables((untildify(String(a)))),
-    from: (a: unknown, original) => {
+    from(a: unknown, original) {
       if (ParameterEqualsDefaults.directory!(a, original)) {
         return original;
       }
@@ -489,7 +496,7 @@ export function resolveParameterTransformFn(
 }
 
 export function resolveMatcher<T extends StringIndexedObject>(
-  settings: ResourceSettings<T>
+  settings: ParsedResourceSettings<T>
 ): (desired: Partial<T>, current: Partial<T>) => boolean {
   return typeof settings.allowMultiple === 'boolean' || !settings.allowMultiple?.matcher
     ? ((desired: Partial<T>, current: Partial<T>) => {

package/src/utils/file-utils.test.ts

@@ -0,0 +1,7 @@
+import { describe, it } from 'vitest';
+
+describe('File utils tests', { timeout: 100_000_000 }, () => {
+  it('Can download a file', async () => {
+    // await FileUtils.downloadFile('https://download.jetbrains.com/webstorm/WebStorm-2025.3.1-aarch64.dmg?_gl=1*1huoi7o*_gcl_aw*R0NMLjE3NjU3NDAwMTcuQ2p3S0NBaUEzZm5KQmhBZ0Vpd0F5cW1ZNVhLVENlbHJOcTk2YXdjZVlfMS1wdE91MXc0WDk2bFJkVDM3QURhUFNJMUtwNVVSVUhxWTJob0NuZ0FRQXZEX0J3RQ..*_gcl_au*MjA0MDQ0MjE2My4xNzYzNjQzNzMz*FPAU*MjA0MDQ0MjE2My4xNzYzNjQzNzMz*_ga*MTYxMDg4MTkzMi4xNzYzNjQzNzMz*_ga_9J976DJZ68*czE3NjYzNjI5ODAkbzEyJGcxJHQxNzY2MzYzMDQwJGo2MCRsMCRoMA..', path.join(process.cwd(), 'google.html'));
+  })
+})

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

@@ -9,10 +9,11 @@ export function splitUserConfig<T extends StringIndexedObject>(
     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, ...parameters } = config;
+  const { type, name, dependsOn, os, ...parameters } = config;
 
   return {
     parameters: parameters as T,
@@ -35,8 +36,7 @@ export function tildify(pathWithTilde: string) {
 }
 
 export function resolvePathWithVariables(pathWithVariables: string) {
-  // @ts-expect-error Ignore this for now
-  return pathWithVariables.replace(/\$([A-Z_]+[A-Z0-9_]*)|\${([A-Z0-9_]*)}/ig, (_, a, b) => process.env[a || b])
+  return pathWithVariables.replace(/\$([A-Z_]+[A-Z0-9_]*)|\${([A-Z0-9_]*)}/ig, (_, a, b) => process.env[a || b]!)
 }
 
 export function addVariablesToPath(pathWithoutVariables: string) {

package/src/utils/index.ts

@@ -2,6 +2,8 @@ import { OS } from 'codify-schemas';
 import os from 'node:os';
 import path from 'node:path';
 
+import { getPty, SpawnStatus } from '../pty/index.js';
+
 export function isDebug(): boolean {
   return process.env.DEBUG != null && process.env.DEBUG.includes('codify'); // TODO: replace with debug library
 }
@@ -40,6 +42,34 @@ export const Utils = {
     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 || '';
 
@@ -138,6 +168,13 @@ export const Utils = {
       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);
+  },
 };
 
 

package/src/utils/internal-utils.test.ts

@@ -8,6 +8,7 @@ describe('Utils tests', () => {
       type: 'type',
       name: 'name',
       dependsOn: ['a', 'b', 'c'],
+      os: ['linux'],
       propA: 'propA',
       propB: 'propB',
       propC: 'propC',

package/src/utils/load-resources.ts

@@ -0,0 +1,53 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import * as url from 'node:url';
+
+export const listAllResources = async (root = path.join(path.dirname(url.fileURLToPath(import.meta.url)), '..', '..', '..', '..')) => {
+  console.log('Dirname', root);
+
+  const resourcesPath = path.join(root, 'src', 'resources')
+
+  const resourceDir = await fs.readdir(resourcesPath);
+  const dedupSet = new Set();
+  const result = new Set<string>();
+
+  for (const folder of resourceDir) {
+    if (await fs.stat(path.join(resourcesPath, folder)).then(s => s.isDirectory()).catch(() => false)) {
+      for (const folderContents of await fs.readdir(path.join(resourcesPath, folder))) {
+        const isDirectory = await fs.stat(path.join(resourcesPath, folder, folderContents)).then(s => s.isDirectory());
+
+        // console.log(folderContents, isDirectory);
+        if (isDirectory) {
+          for (const innerContents of await fs.readdir(path.join(resourcesPath, folder, folderContents))) {
+            if (!dedupSet.has(path.join(resourcesPath, folder, folderContents))) {
+              dedupSet.add(path.join(resourcesPath, folder, folderContents));
+              addResourceFromDir(path.join(resourcesPath, folder,folderContents), result);
+            }
+          }
+        } else {
+          if (!dedupSet.has(path.join(resourcesPath, folder))) {
+            dedupSet.add(path.join(resourcesPath, folder));
+            addResourceFromDir(path.join(resourcesPath, folder), result);
+          }
+        }
+      }
+    } else {
+      throw new Error('Only directories are allowed in resources folder')
+    }
+  }
+
+  return [...result];
+}
+
+
+
+function addResourceFromDir(dir: string, result: Set<string>): void {
+  try {
+    const resourceFile = path.resolve(path.join(dir, 'resource.ts'));
+    if (!(fs.stat(resourceFile).then((s) => s.isFile())).catch(() => false)) {
+      return;
+    }
+
+    result.add(resourceFile);
+  } catch {}
+}

package/src/utils/package-json-utils.ts

@@ -0,0 +1,40 @@
+import * as fs from 'node:fs';
+import path from 'node:path';
+
+/**
+ * Find the nearest package.json starting from a directory and walking upward.
+ * @param {string} startDir - Directory to start searching from
+ * @returns {string|null} Absolute path to package.json or null if not found
+ */
+export function findNearestPackageJson(startDir = process.cwd()) {
+  let currentDir = path.resolve(startDir);
+
+  while (true) {
+    const pkgPath = path.join(currentDir, "package.json");
+
+    if (fs.existsSync(pkgPath)) {
+      return pkgPath;
+    }
+
+    const parentDir = path.dirname(currentDir);
+    if (parentDir === currentDir) {
+      // Reached filesystem root
+      return null;
+    }
+
+    currentDir = parentDir;
+  }
+}
+
+/**
+ * Read and parse the nearest package.json
+ * @param {string} startDir
+ * @returns {object|null}
+ */
+export function readNearestPackageJson(startDir: string = process.cwd()) {
+  const pkgPath = findNearestPackageJson(startDir);
+  if (!pkgPath) return null;
+
+  const contents = fs.readFileSync(pkgPath, 'utf8');
+  return JSON.parse(contents);
+}