codify-plugin-lib 1.0.182-beta7 → 1.0.182-beta71

package/dist/resource/parsed-resource-settings.js

@@ -1,20 +1,34 @@
+import { ZodObject, z } from 'zod';
 import { StatefulParameterController } from '../stateful-parameter/stateful-parameter-controller.js';
 import { resolveElementEqualsFn, resolveEqualsFn, resolveMatcher, resolveParameterTransformFn } from './resource-settings.js';
 export class ParsedResourceSettings {
     cache = new Map();
     id;
+    description;
     schema;
     allowMultiple;
     removeStatefulParametersBeforeDestroy;
     dependencies;
     transformation;
     operatingSystems;
+    linuxDistros;
     isSensitive;
     settings;
     constructor(settings) {
         this.settings = settings;
-        const { parameterSettings, ...rest } = settings;
+        const { parameterSettings, schema, ...rest } = settings;
         Object.assign(this, rest);
+        if (schema) {
+            this.schema = schema instanceof ZodObject
+                ? z.toJSONSchema(schema.strict(), {
+                    target: 'draft-7',
+                    override(ctx) {
+                        ctx.jsonSchema.title = settings.id;
+                        ctx.jsonSchema.description = settings.description ?? `${settings.id} resource. Can be used to manage ${settings.id}`;
+                    }
+                })
+                : schema;
+        }
         this.validateSettings();
     }
     get typeId() {
@@ -118,7 +132,7 @@ export class ParsedResourceSettings {
             && typeof this.settings.allowMultiple === 'object' && this.settings.allowMultiple?.identifyingParameters?.includes(k))) {
             throw new Error(`Resource: ${this.id}. Stateful parameters are not allowed to be identifying parameters for allowMultiple.`);
         }
-        const schema = this.settings.schema;
+        const schema = this.schema;
         if (!this.settings.importAndDestroy && (schema?.oneOf
             && Array.isArray(schema.oneOf)
             && schema.oneOf.some((s) => s.required))

package/dist/resource/resource-controller.js

@@ -17,16 +17,16 @@ export class ResourceController {
         this.settings = resource.getSettings();
         this.typeId = this.settings.id;
         this.dependencies = this.settings.dependencies ?? [];
-        if (this.settings.schema) {
+        this.parsedSettings = new ParsedResourceSettings(this.settings);
+        if (this.parsedSettings.schema) {
             this.ajv = new Ajv({
                 allErrors: true,
                 strict: true,
                 strictRequired: false,
                 allowUnionTypes: true
             });
-            this.schemaValidator = this.ajv.compile(this.settings.schema);
+            this.schemaValidator = this.ajv.compile(this.parsedSettings.schema);
         }
-        this.parsedSettings = new ParsedResourceSettings(this.settings);
     }
     async initialize() {
         return this.resource.initialize();
@@ -374,8 +374,8 @@ ${JSON.stringify(refresh, null, 2)}
             .sort((a, b) => this.parsedSettings.statefulParameterOrder.get(a.name) - this.parsedSettings.statefulParameterOrder.get(b.name));
     }
     getAllParameterKeys() {
-        return this.settings.schema
-            ? Object.keys(this.settings.schema?.properties)
+        return this.parsedSettings.schema
+            ? Object.keys(this.parsedSettings.schema?.properties)
             : Object.keys(this.parsedSettings.parameterSettings);
     }
     getParametersToRefreshForImport(parameters, context) {

package/dist/resource/resource-settings.d.ts

@@ -1,6 +1,8 @@
 import { JSONSchemaType } from 'ajv';
-import { OS, StringIndexedObject } from 'codify-schemas';
+import { LinuxDistro, OS, StringIndexedObject } from 'codify-schemas';
+import { ZodObject } from 'zod';
 import { ArrayStatefulParameter, StatefulParameter } from '../stateful-parameter/stateful-parameter.js';
+import { ParsedResourceSettings } from './parsed-resource-settings.js';
 import { RefreshContext } from './resource.js';
 export interface InputTransformation {
     to: (input: any) => Promise<any> | any;
@@ -18,15 +20,23 @@ export interface ResourceSettings<T extends StringIndexedObject> {
      * List of supported operating systems
      */
     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
      */
-    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.
      * This differs from the parameter level sensitivity which also prevents the parameter value from being displayed in the plan.
      */
     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
@@ -290,4 +300,4 @@ export declare function resolveEqualsFn(parameter: ParameterSetting): (desired:
 export declare function resolveElementEqualsFn(parameter: ArrayParameterSetting): (desired: unknown, current: unknown) => boolean;
 export declare function resolveFnFromEqualsFnOrString(fnOrString: ((a: unknown, b: unknown) => boolean) | ParameterSettingType | undefined): ((a: unknown, b: unknown) => boolean) | undefined;
 export declare function resolveParameterTransformFn(parameter: ParameterSetting): InputTransformation | undefined;
-export declare function resolveMatcher<T extends StringIndexedObject>(settings: ResourceSettings<T>): (desired: Partial<T>, current: Partial<T>) => boolean;
+export declare function resolveMatcher<T extends StringIndexedObject>(settings: ParsedResourceSettings<T>): (desired: Partial<T>, current: Partial<T>) => boolean;

package/dist/resource/resource-settings.js

@@ -3,7 +3,7 @@ import path from 'node:path';
 import { addVariablesToPath, areArraysEqual, resolvePathWithVariables, tildify, untildify } from '../utils/functions.js';
 const ParameterEqualsDefaults = {
     'boolean': (a, b) => Boolean(a) === Boolean(b),
-    'directory': (a, b) => {
+    'directory'(a, b) {
         let transformedA = resolvePathWithVariables(untildify(String(a)));
         let transformedB = resolvePathWithVariables(untildify(String(b)));
         if (transformedA.startsWith('.')) { // Only relative paths start with '.'
@@ -65,7 +65,7 @@ export function resolveFnFromEqualsFnOrString(fnOrString) {
 const ParameterTransformationDefaults = {
     'directory': {
         to: (a) => resolvePathWithVariables((untildify(String(a)))),
-        from: (a, original) => {
+        from(a, original) {
             if (ParameterEqualsDefaults.directory(a, original)) {
                 return original;
             }

package/dist/test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test.js

@@ -0,0 +1,5 @@
+import { SequentialPty } from './pty/seqeuntial-pty.js';
+import { VerbosityLevel } from './utils/verbosity-level.js';
+VerbosityLevel.set(1);
+const $ = new SequentialPty();
+await $.spawn('sudo ls', { interactive: true });

package/dist/utils/file-utils.d.ts

@@ -1,16 +1,23 @@
 export declare class FileUtils {
     static downloadFile(url: string, destination: string): Promise<void>;
-    static addToStartupFile(line: string): Promise<void>;
-    static addAllToStartupFile(lines: string[]): Promise<void>;
-    static addPathToPrimaryShellRc(value: string, prepend: boolean): Promise<void>;
+    static addToShellRc(line: string): Promise<void>;
+    static addAllToShellRc(lines: string[]): Promise<void>;
+    /**
+     * 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 addPathToShellRc(value: string, prepend: boolean): Promise<void>;
+    static removeFromFile(filePath: string, search: string): Promise<void>;
+    static removeLineFromFile(filePath: string, search: RegExp | string): Promise<void>;
+    static removeLineFromShellRc(search: RegExp | string): Promise<void>;
+    static removeAllLinesFromShellRc(searches: Array<RegExp | string>): Promise<void>;
+    static appendToFileWithSpacing(file: string, textToInsert: string): string;
     static dirExists(path: string): Promise<boolean>;
     static fileExists(path: string): Promise<boolean>;
     static exists(path: string): Promise<boolean>;
     static checkDirExistsOrThrowIfFile(path: string): Promise<boolean>;
     static createDirIfNotExists(path: string): Promise<void>;
-    static removeFromFile(filePath: string, search: string): Promise<void>;
-    static removeLineFromFile(filePath: string, search: RegExp | string): Promise<void>;
-    static removeLineFromPrimaryShellRc(search: RegExp | string): Promise<void>;
-    static appendToFileWithSpacing(file: string, textToInsert: string): string;
     private static calculateEndingNewLines;
 }

package/dist/utils/file-utils.js

@@ -18,7 +18,7 @@ export class FileUtils {
         await finished(Readable.fromWeb(body).pipe(ws));
         console.log(`Finished downloading to ${destination}`);
     }
-    static async addToStartupFile(line) {
+    static async addToShellRc(line) {
         const lineToInsert = addLeadingSpacer(addTrailingSpacer(line));
         await fs.appendFile(Utils.getPrimaryShellRc(), lineToInsert);
         function addLeadingSpacer(line) {
@@ -32,14 +32,23 @@ export class FileUtils {
                 : line + '\n';
         }
     }
-    static async addAllToStartupFile(lines) {
+    static async addAllToShellRc(lines) {
         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);
     }
-    static async addPathToPrimaryShellRc(value, prepend) {
+    /**
+     * 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, prepend) {
+        if (await Utils.isDirectoryOnPath(value)) {
+            return;
+        }
         const shellRc = Utils.getPrimaryShellRc();
         console.log(`Saving path: ${value} to ${shellRc}`);
         if (prepend) {
@@ -48,53 +57,6 @@ ${lines.join('\n')}`);
         }
         await fs.appendFile(shellRc, `\nexport PATH=${value}:$PATH;`, { encoding: 'utf8' });
     }
-    static async dirExists(path) {
-        let stat;
-        try {
-            stat = await fs.stat(path);
-            return stat.isDirectory();
-        }
-        catch {
-            return false;
-        }
-    }
-    static async fileExists(path) {
-        let stat;
-        try {
-            stat = await fs.stat(path);
-            return stat.isFile();
-        }
-        catch {
-            return false;
-        }
-    }
-    static async exists(path) {
-        try {
-            await fs.stat(path);
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    static async checkDirExistsOrThrowIfFile(path) {
-        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) {
-        if (!fsSync.existsSync(path)) {
-            await fs.mkdir(path, { recursive: true });
-        }
-    }
     static async removeFromFile(filePath, search) {
         const contents = await fs.readFile(filePath, 'utf8');
         const newContents = contents.replaceAll(search, '');
@@ -131,9 +93,14 @@ ${lines.join('\n')}`);
         await fs.writeFile(filePath, lines.join('\n'));
         console.log(`Removed line: ${search} from ${filePath}`);
     }
-    static async removeLineFromPrimaryShellRc(search) {
+    static async removeLineFromShellRc(search) {
         return FileUtils.removeLineFromFile(Utils.getPrimaryShellRc(), search);
     }
+    static async removeAllLinesFromShellRc(searches) {
+        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;
@@ -150,6 +117,53 @@ ${lines.join('\n')}`);
             : Math.max(0, 2 - endingNewLines);
         return lines.join('\n') + '\n'.repeat(numNewLines) + textToInsert;
     }
+    static async dirExists(path) {
+        let stat;
+        try {
+            stat = await fs.stat(path);
+            return stat.isDirectory();
+        }
+        catch {
+            return false;
+        }
+    }
+    static async fileExists(path) {
+        let stat;
+        try {
+            stat = await fs.stat(path);
+            return stat.isFile();
+        }
+        catch {
+            return false;
+        }
+    }
+    static async exists(path) {
+        try {
+            await fs.stat(path);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    static async checkDirExistsOrThrowIfFile(path) {
+        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) {
+        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
     static calculateEndingNewLines(lines) {

package/dist/utils/functions.js

@@ -5,9 +5,10 @@ export function splitUserConfig(config) {
         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,
         coreParameters,
@@ -24,7 +25,6 @@ export function tildify(pathWithTilde) {
     return homeDirectory ? pathWithTilde.replace(homeDirectory, '~') : pathWithTilde;
 }
 export function resolvePathWithVariables(pathWithVariables) {
-    // @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]);
 }
 export function addVariablesToPath(pathWithoutVariables) {

package/dist/utils/index.d.ts

@@ -1,4 +1,4 @@
-import { OS } from 'codify-schemas';
+import { LinuxDistro, OS } from 'codify-schemas';
 export declare function isDebug(): boolean;
 export declare enum Shell {
     ZSH = "zsh",
@@ -20,7 +20,27 @@ export declare const Utils: {
     };
     isMacOS(): boolean;
     isLinux(): boolean;
+    isArmArch(): Promise<boolean>;
+    isHomebrewInstalled(): Promise<boolean>;
+    isRosetta2Installed(): Promise<boolean>;
     getShell(): Shell | undefined;
     getPrimaryShellRc(): string;
     getShellRcFiles(): string[];
+    isDirectoryOnPath(directory: string): Promise<boolean>;
+    assertBrewInstalled(): Promise<void>;
+    /**
+     * 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
+     */
+    installViaPkgMgr(packageName: string): Promise<void>;
+    uninstallViaPkgMgr(packageName: string): Promise<boolean>;
+    getLinuxDistro(): Promise<LinuxDistro | undefined>;
+    isUbuntu(): Promise<boolean>;
+    isDebian(): Promise<boolean>;
+    isArch(): Promise<boolean>;
+    isCentOS(): Promise<boolean>;
+    isFedora(): Promise<boolean>;
+    isRHEL(): Promise<boolean>;
+    isDebianBased(): boolean;
+    isRedhatBased(): boolean;
 };

package/dist/utils/index.js

@@ -1,5 +1,9 @@
+import { LinuxDistro } 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() {
     return process.env.DEBUG != null && process.env.DEBUG.includes('codify'); // TODO: replace with debug library
 }
@@ -28,6 +32,29 @@ export const Utils = {
     isLinux() {
         return os.platform() === 'linux';
     },
+    async isArmArch() {
+        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() {
+        const $ = getPty();
+        const query = await $.spawnSafe('which brew', { interactive: true });
+        return query.status === SpawnStatus.SUCCESS;
+    },
+    async isRosetta2Installed() {
+        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() {
         const shell = process.env.SHELL || '';
         if (shell.endsWith('bash')) {
@@ -108,4 +135,137 @@ export const Utils = {
             path.join(homeDir, '.profile'),
         ];
     },
+    async isDirectoryOnPath(directory) {
+        const $ = getPty();
+        const { data: pathQuery } = await $.spawn('echo $PATH', { interactive: true });
+        const lines = pathQuery.split(':');
+        return lines.includes(directory);
+    },
+    async assertBrewInstalled() {
+        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) {
+        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) {
+        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() {
+        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) ? distroId : undefined;
+            }
+        }
+        return undefined;
+    },
+    async isUbuntu() {
+        return (await this.getLinuxDistro()) === LinuxDistro.UBUNTU;
+    },
+    async isDebian() {
+        return (await this.getLinuxDistro()) === LinuxDistro.DEBIAN;
+    },
+    async isArch() {
+        return (await this.getLinuxDistro()) === LinuxDistro.ARCH;
+    },
+    async isCentOS() {
+        return (await this.getLinuxDistro()) === LinuxDistro.CENTOS;
+    },
+    async isFedora() {
+        return (await this.getLinuxDistro()) === LinuxDistro.FEDORA;
+    },
+    async isRHEL() {
+        return (await this.getLinuxDistro()) === LinuxDistro.RHEL;
+    },
+    isDebianBased() {
+        return fsSync.existsSync('/etc/debian_version');
+    },
+    isRedhatBased() {
+        return fsSync.existsSync('/etc/redhat-release');
+    }
 };

package/dist/utils/load-resources.d.ts

@@ -0,0 +1 @@
+export declare const listAllResources: (root?: string) => Promise<string[]>;

package/dist/utils/load-resources.js

@@ -0,0 +1,46 @@
+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();
+    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, result) {
+    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/dist/utils/package-json-utils.d.ts

@@ -0,0 +1,12 @@
+/**
+ * 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 declare function findNearestPackageJson(startDir?: string): string | null;
+/**
+ * Read and parse the nearest package.json
+ * @param {string} startDir
+ * @returns {object|null}
+ */
+export declare function readNearestPackageJson(startDir?: string): any;

package/dist/utils/package-json-utils.js

@@ -0,0 +1,34 @@
+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 = process.cwd()) {
+    const pkgPath = findNearestPackageJson(startDir);
+    if (!pkgPath)
+        return null;
+    const contents = fs.readFileSync(pkgPath, 'utf8');
+    return JSON.parse(contents);
+}