@codifycli/plugin-core 1.2.5-beta.3 → 1.2.5-beta.4

package/dist/resource/stateful-parameter.d.ts

@@ -0,0 +1,165 @@
+import { StringIndexedObject } from 'codify-schemas';
+import { Plan } from '../plan/plan.js';
+import { ArrayParameterSetting, ParameterSetting } from './resource-settings.js';
+/**
+ * A stateful parameter represents a parameter that holds state on the system (can be created, destroyed) but
+ * is still tied to the overall lifecycle of a resource.
+ *
+ * **Examples include:**
+ * 1. Homebrew formulas are stateful parameters. They can be installed and uninstalled but they are still tied to the
+ * overall lifecycle of homebrew
+ * 2. Nvm installed node versions are stateful parameters. Nvm can install and uninstall different versions of Node but
+ * these versions are tied to the lifecycle of nvm. If nvm is uninstalled then so are the Node versions.
+ */
+export declare abstract class StatefulParameter<T extends StringIndexedObject, V extends T[keyof T]> {
+    /**
+     * Parameter settings for the stateful parameter. Stateful parameters share the same parameter settings as
+     * regular parameters except that they cannot be of type 'stateful'. See {@link ParameterSetting} for more
+     * information on available settings.
+     *
+     * @return The parameter settings
+     */
+    getSettings(): ParameterSetting;
+    /**
+     * Refresh the status of the stateful parameter on the system. This method works similarly to {@link Resource.refresh}.
+     * Return the value of the stateful parameter or null if not found.
+     *
+     * @param desired The desired value of the user.
+     * @param config The desired config
+     *
+     * @return The value of the stateful parameter currently on the system or null if not found
+     */
+    abstract refresh(desired: V | null, config: Partial<T>): Promise<V | null>;
+    /**
+     * Create the stateful parameter on the system. This method is similar {@link Resource.create} except that its only
+     * applicable to the stateful parameter. For resource `CREATE` operations, this method will be called after the
+     * resource is successfully created. The add method is called when a ParameterChange is ADD in a plan. The add
+     * method is only called when the stateful parameter does not currently exist.
+     *
+     * **Example (Homebrew formula):**
+     * 1. Add is called with a value of:
+     * ```
+     * ['jq', 'jenv']
+     * ```
+     * 2. Add handles the request by calling `brew install --formulae jq jenv`
+     *
+     * @param valueToAdd The desired value of the stateful parameter.
+     * @param plan The overall plan that contains the ADD
+     */
+    abstract add(valueToAdd: V, plan: Plan<T>): Promise<void>;
+    /**
+     * Modify the state of a stateful parameter on the system. This method is similar to {@link Resource.modify} except that its only
+     * applicable to the stateful parameter.
+     *
+     * **Example (Git email parameter):**
+     * 1. Add is called with a value of:
+     * ```
+     * newValue: 'email+new@gmail.com', previousValue: 'email+old@gmail.com'
+     * ```
+     * 2. Modify handles the request by calling `git config --global user.email email+new@gmail.com`
+     *
+     * @param newValue The desired value of the stateful parameter
+     * @param previousValue The current value of the stateful parameter
+     * @param plan The overall plan
+     */
+    abstract modify(newValue: V, previousValue: V, plan: Plan<T>): Promise<void>;
+    /**
+     * Create the stateful parameter on the system. This method is similar {@link Resource.destroy} except that its only
+     * applicable to the stateful parameter. The remove method is only called when the stateful parameter already currently exist.
+     * This method corresponds to REMOVE parameter operations in a plan.
+     * For resource `DESTORY`, this method is only called if the {@link ResourceSettings.removeStatefulParametersBeforeDestroy}
+     * is set to true. This method will be called before the resource is destroyed.
+     *
+     * **Example (Homebrew formula):**
+     * 1. Remove is called with a value of:
+     * ```
+     * ['jq', 'jenv']
+     * ```
+     * 2. Remove handles the request by calling `brew uninstall --formulae jq jenv`
+     *
+     * @param valueToRemove The value to remove from the stateful parameter.
+     * @param plan The overall plan that contains the REMOVE
+     */
+    abstract remove(valueToRemove: V, plan: Plan<T>): Promise<void>;
+}
+/**
+ * A specialized version of {@link StatefulParameter } that is used for stateful parameters which are arrays.
+ * A stateful parameter represents a parameter that holds state on the system (can be created, destroyed) but
+ * is still tied to the overall lifecycle of a resource.
+ *
+ * **Examples:**
+ * - Homebrew formulas are arrays
+ * - Pyenv python versions are arrays
+ */
+export declare abstract class ArrayStatefulParameter<T extends StringIndexedObject, V> extends StatefulParameter<T, any> {
+    /**
+     * Parameter level settings. Type must be 'array'.
+     */
+    getSettings(): ArrayParameterSetting;
+    /**
+     * It is not recommended to override the `add` method. A addItem helper method is available to operate on
+     * individual elements of the desired array. See {@link StatefulParameter.add} for more info.
+     *
+     * @param valuesToAdd The array of values to add
+     * @param plan The overall plan
+     *
+     */
+    add(valuesToAdd: V[], plan: Plan<T>): Promise<void>;
+    /**
+     * It is not recommended to override the `modify` method. `addItem` and `removeItem` will be called accordingly based
+     * on the modifications. See {@link StatefulParameter.modify} for more info.
+     *
+     * @param newValues The new array value
+     * @param previousValues The previous array value
+     * @param plan The overall plan
+     */
+    modify(newValues: V[], previousValues: V[], plan: Plan<T>): Promise<void>;
+    /**
+     * It is not recommended to override the `remove` method. A removeItem helper method is available to operate on
+     * individual elements of the desired array. See {@link StatefulParameter.remove} for more info.
+     *
+     * @param valuesToAdd The array of values to add
+     * @param plan The overall plan
+     *
+     */
+    remove(valuesToRemove: V[], plan: Plan<T>): Promise<void>;
+    /**
+     * See {@link StatefulParameter.refresh} for more info.
+     *
+     * @param desired The desired value to refresh
+     * @return The current value on the system or null if not found.
+     */
+    abstract refresh(desired: V[] | null, config: Partial<T>): Promise<V[] | null>;
+    /**
+     * Helper method that gets called when individual elements of the array need to be added. See {@link StatefulParameter.add}
+     * for more information.
+     *
+     * Example (Homebrew formula):
+     * 1. The stateful parameter receives an input of:
+     * ```
+     * ['jq', 'jenv', 'docker']
+     * ```
+     * 2. Internally the stateful parameter will iterate the array and call `addItem` for each element
+     * 3. Override addItem and install each formula using `brew install --formula jq`
+     *
+     * @param item The item to add (install)
+     * @param plan The overall plan
+     */
+    abstract addItem(item: V, plan: Plan<T>): Promise<void>;
+    /**
+     * Helper method that gets called when individual elements of the array need to be removed. See {@link StatefulParameter.remove}
+     * for more information.
+     *
+     * Example (Homebrew formula):
+     * 1. The stateful parameter receives an input of:
+     * ```
+     * ['jq', 'jenv', 'docker']
+     * ```
+     * 2. Internally the stateful parameter will iterate the array and call `removeItem` for each element
+     * 3. Override removeItem and uninstall each formula using `brew uninstall --formula jq`
+     *
+     * @param item The item to remove (uninstall)
+     * @param plan The overall plan
+     */
+    abstract removeItem(item: V, plan: Plan<T>): Promise<void>;
+}

package/dist/resource/stateful-parameter.js

@@ -0,0 +1,94 @@
+/**
+ * A stateful parameter represents a parameter that holds state on the system (can be created, destroyed) but
+ * is still tied to the overall lifecycle of a resource.
+ *
+ * **Examples include:**
+ * 1. Homebrew formulas are stateful parameters. They can be installed and uninstalled but they are still tied to the
+ * overall lifecycle of homebrew
+ * 2. Nvm installed node versions are stateful parameters. Nvm can install and uninstall different versions of Node but
+ * these versions are tied to the lifecycle of nvm. If nvm is uninstalled then so are the Node versions.
+ */
+export class StatefulParameter {
+    /**
+     * Parameter settings for the stateful parameter. Stateful parameters share the same parameter settings as
+     * regular parameters except that they cannot be of type 'stateful'. See {@link ParameterSetting} for more
+     * information on available settings.
+     *
+     * @return The parameter settings
+     */
+    getSettings() {
+        return {};
+    }
+}
+/**
+ * A specialized version of {@link StatefulParameter } that is used for stateful parameters which are arrays.
+ * A stateful parameter represents a parameter that holds state on the system (can be created, destroyed) but
+ * is still tied to the overall lifecycle of a resource.
+ *
+ * **Examples:**
+ * - Homebrew formulas are arrays
+ * - Pyenv python versions are arrays
+ */
+export class ArrayStatefulParameter extends StatefulParameter {
+    /**
+     * Parameter level settings. Type must be 'array'.
+     */
+    getSettings() {
+        return { type: 'array' };
+    }
+    /**
+     * It is not recommended to override the `add` method. A addItem helper method is available to operate on
+     * individual elements of the desired array. See {@link StatefulParameter.add} for more info.
+     *
+     * @param valuesToAdd The array of values to add
+     * @param plan The overall plan
+     *
+     */
+    async add(valuesToAdd, plan) {
+        for (const value of valuesToAdd) {
+            await this.addItem(value, plan);
+        }
+    }
+    /**
+     * It is not recommended to override the `modify` method. `addItem` and `removeItem` will be called accordingly based
+     * on the modifications. See {@link StatefulParameter.modify} for more info.
+     *
+     * @param newValues The new array value
+     * @param previousValues The previous array value
+     * @param plan The overall plan
+     */
+    async modify(newValues, previousValues, plan) {
+        // TODO: I don't think this works with duplicate elements. Solve at another time
+        const valuesToAdd = newValues.filter((n) => !previousValues.some((p) => {
+            if (this.getSettings()?.isElementEqual) {
+                return this.getSettings().isElementEqual(n, p);
+            }
+            return n === p;
+        }));
+        const valuesToRemove = previousValues.filter((p) => !newValues.some((n) => {
+            if (this.getSettings().isElementEqual) {
+                return this.getSettings().isElementEqual(n, p);
+            }
+            return n === p;
+        }));
+        for (const value of valuesToAdd) {
+            await this.addItem(value, plan);
+        }
+        for (const value of valuesToRemove) {
+            await this.removeItem(value, plan);
+        }
+    }
+    /**
+     * It is not recommended to override the `remove` method. A removeItem helper method is available to operate on
+     * individual elements of the desired array. See {@link StatefulParameter.remove} for more info.
+     *
+     * @param valuesToAdd The array of values to add
+     * @param plan The overall plan
+     *
+     */
+    async remove(valuesToRemove, plan) {
+        for (const value of valuesToRemove) {
+            await this.removeItem(value, plan);
+        }
+    }
+}

package/dist/scripts/deploy.d.ts

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

package/dist/scripts/deploy.js

@@ -0,0 +1,2 @@
+console.log('Deploying!!');
+export {};

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/codify-spawn.d.ts

@@ -0,0 +1,29 @@
+import { SpawnOptions } from 'node:child_process';
+export declare enum SpawnStatus {
+    SUCCESS = "success",
+    ERROR = "error"
+}
+export interface SpawnResult {
+    status: SpawnStatus;
+    data: string;
+}
+type CodifySpawnOptions = {
+    cwd?: string;
+    throws?: boolean;
+    requiresRoot?: boolean;
+    requestsTTY?: boolean;
+} & Omit<SpawnOptions, 'detached' | 'shell' | 'stdio'>;
+/**
+ *
+ * @param cmd Command to run. Ex: `rm -rf`
+ * @param opts Standard options for node spawn. Additional argument:
+ * throws determines if a shell will throw a JS error. Defaults to true
+ *
+ * @see promiseSpawn
+ * @see spawn
+ *
+ * @returns SpawnResult { status: SUCCESS | ERROR; data: string }
+ */
+export declare function codifySpawn(cmd: string, opts?: CodifySpawnOptions): Promise<SpawnResult>;
+export declare function isDebug(): boolean;
+export {};

package/dist/utils/codify-spawn.js

@@ -0,0 +1,136 @@
+import { Ajv } from 'ajv';
+import { MessageCmd, SudoRequestResponseDataSchema } from 'codify-schemas';
+import { nanoid } from 'nanoid';
+import { spawn } from 'node:child_process';
+import stripAnsi from 'strip-ansi';
+import { VerbosityLevel } from './utils.js';
+import { SudoError } from '../errors.js';
+const ajv = new Ajv({
+    strict: true,
+});
+const validateSudoRequestResponse = ajv.compile(SudoRequestResponseDataSchema);
+export var SpawnStatus;
+(function (SpawnStatus) {
+    SpawnStatus["SUCCESS"] = "success";
+    SpawnStatus["ERROR"] = "error";
+})(SpawnStatus || (SpawnStatus = {}));
+/**
+ *
+ * @param cmd Command to run. Ex: `rm -rf`
+ * @param opts Standard options for node spawn. Additional argument:
+ * throws determines if a shell will throw a JS error. Defaults to true
+ *
+ * @see promiseSpawn
+ * @see spawn
+ *
+ * @returns SpawnResult { status: SUCCESS | ERROR; data: string }
+ */
+export async function codifySpawn(cmd, opts) {
+    const throws = opts?.throws ?? true;
+    console.log(`Running command: ${cmd}` + (opts?.cwd ? `(${opts?.cwd})` : ''));
+    try {
+        // TODO: Need to benchmark the effects of using sh vs zsh for shell.
+        //  Seems like zsh shells run slower
+        const result = await (opts?.requiresRoot
+            ? externalSpawnWithSudo(cmd, opts)
+            : internalSpawn(cmd, opts ?? {}));
+        if (result.status !== SpawnStatus.SUCCESS) {
+            throw new Error(result.data);
+        }
+        return result;
+    }
+    catch (error) {
+        if (isDebug()) {
+            console.error(`CodifySpawn error for command ${cmd}`, error);
+        }
+        // @ts-ignore
+        if (error.message?.startsWith('sudo:')) {
+            throw new SudoError(cmd);
+        }
+        if (throws) {
+            throw error;
+        }
+        if (error instanceof Error) {
+            return {
+                status: SpawnStatus.ERROR,
+                data: error.message,
+            };
+        }
+        return {
+            status: SpawnStatus.ERROR,
+            data: String(error),
+        };
+    }
+}
+async function internalSpawn(cmd, opts) {
+    return new Promise((resolve) => {
+        const output = [];
+        // If TERM_PROGRAM=Apple_Terminal is set then ANSI escape characters may be included
+        // in the response.
+        const env = { ...process.env, ...opts.env, TERM_PROGRAM: 'codify', COMMAND_MODE: 'unix2003', COLORTERM: 'truecolor' };
+        const shell = getDefaultShell();
+        const rcFile = shell === 'zsh' ? '~/.zshrc' : '~/.bashrc';
+        // Source start up shells to emulate a users environment vs. a non-interactive non-login shell script
+        // Ignore all stdin
+        // If tty is requested then we'll need to sleep 1 to avoid race conditions. This is because if the terminal updates async after the tty message is
+        // displayed then it'll disappear. By adding sleep 1 it'll allow ink.js to finish all the updates before the tty message is shown
+        const _process = spawn(`source ${rcFile}; ${opts.requestsTTY ? 'sleep 1;' : ''}${cmd}`, [], {
+            ...opts,
+            stdio: ['ignore', 'pipe', 'pipe'],
+            shell,
+            env
+        });
+        const { stdout, stderr, stdin } = _process;
+        stdout.setEncoding('utf8');
+        stderr.setEncoding('utf8');
+        stdout.on('data', (data) => {
+            output.push(data.toString());
+        });
+        stderr.on('data', (data) => {
+            output.push(data.toString());
+        });
+        _process.on('error', (data) => { });
+        // please node that this is not a full replacement for 'inherit'
+        // the child process can and will detect if stdout is a pty and change output based on it
+        // the terminal context is lost & ansi information (coloring) etc will be lost
+        if (stdout && stderr && VerbosityLevel.get() > 0) {
+            stdout.pipe(process.stdout);
+            stderr.pipe(process.stderr);
+        }
+        _process.on('close', (code) => {
+            resolve({
+                status: code === 0 ? SpawnStatus.SUCCESS : SpawnStatus.ERROR,
+                data: stripAnsi(output.join('\n')),
+            });
+        });
+    });
+}
+async function externalSpawnWithSudo(cmd, opts) {
+    return new Promise((resolve) => {
+        const requestId = nanoid(8);
+        const listener = (data) => {
+            if (data.requestId === requestId) {
+                process.removeListener('message', listener);
+                if (!validateSudoRequestResponse(data.data)) {
+                    throw new Error(`Invalid response for sudo request: ${JSON.stringify(validateSudoRequestResponse.errors, null, 2)}`);
+                }
+                resolve(data.data);
+            }
+        };
+        process.on('message', listener);
+        process.send({
+            cmd: MessageCmd.SUDO_REQUEST,
+            data: {
+                command: cmd,
+                options: opts ?? {},
+            },
+            requestId
+        });
+    });
+}
+export function isDebug() {
+    return process.env.DEBUG != null && process.env.DEBUG.includes('codify'); // TODO: replace with debug library
+}
+function getDefaultShell() {
+    return process.platform === 'darwin' ? 'zsh' : 'bash';
+}

package/dist/utils/index.d.ts

@@ -53,6 +53,17 @@ export declare const Utils: {
     isHomebrewInstalled(): Promise<boolean>;
     isRosetta2Installed(): Promise<boolean>;
     getShell(): Shell | undefined;
+    /**
+     * Resolves the shell binary to launch commands with. `process.env.SHELL` is
+     * only set when Codify is launched from a terminal — GUI launches (e.g. the
+     * Codify desktop app via launchd) do not export it, in which case
+     * `node-pty` would fall back to `/bin/sh`, which does not source the user's
+     * `~/.zshrc`/`~/.bash_profile`. That drops user env (e.g. TART_HOME, PATH
+     * additions), breaking resource refresh. Fall back to the login shell from
+     * the passwd database (os.userInfo().shell) so we always use the user's real
+     * shell regardless of how Codify was started.
+     */
+    getDefaultShell(): string;
     getPrimaryShellRc(): string;
     getShellRcFiles(): string[];
     isDirectoryOnPath(directory: string): Promise<boolean>;

package/dist/utils/index.js

@@ -85,6 +85,19 @@ export const Utils = {
         }
         return undefined;
     },
+    /**
+     * Resolves the shell binary to launch commands with. `process.env.SHELL` is
+     * only set when Codify is launched from a terminal — GUI launches (e.g. the
+     * Codify desktop app via launchd) do not export it, in which case
+     * `node-pty` would fall back to `/bin/sh`, which does not source the user's
+     * `~/.zshrc`/`~/.bash_profile`. That drops user env (e.g. TART_HOME, PATH
+     * additions), breaking resource refresh. Fall back to the login shell from
+     * the passwd database (os.userInfo().shell) so we always use the user's real
+     * shell regardless of how Codify was started.
+     */
+    getDefaultShell() {
+        return process.env.SHELL || os.userInfo().shell || '/bin/zsh';
+    },
     getPrimaryShellRc() {
         return this.getShellRcFiles()[0];
     },
@@ -180,7 +193,10 @@ Brew can be installed using Codify:
             if (brewOpts?.flags)
                 flags.push(...brewOpts.flags);
             const flagStr = flags.length > 0 ? `${flags.join(' ')} ` : '';
-            await $.spawn(`brew install ${flagStr}${packageName}`, { interactive: true, env: { HOMEBREW_NO_AUTO_UPDATE: 1, HOMEBREW_NO_ASK: 1 } });
+            // Redirect stdin from /dev/null so Homebrew's ask.rb detects a non-TTY stdin
+            // and skips any [y/n] confirmation prompts (e.g. "Do you want to proceed with the installation?").
+            // NONINTERACTIVE=1 alone is not sufficient — Homebrew's prompt only checks tty?, not that var.
+            await $.spawn(`brew install ${flagStr}${packageName} < /dev/null`, { interactive: true, env: { HOMEBREW_NO_AUTO_UPDATE: 1, NONINTERACTIVE: 1 } });
             return;
         }
         const useApt = forcePackageManager === PackageManager.APT || (!forcePackageManager && Utils.isLinux());
@@ -272,7 +288,7 @@ Brew can be installed using Codify:
             const flagStr = flags.length > 0 ? `${flags.join(' ')} ` : '';
             const { status } = await $.spawnSafe(`brew uninstall ${flagStr}${packageName}`, {
                 interactive: true,
-                env: { HOMEBREW_NO_AUTO_UPDATE: 1, HOMEBREW_NO_ASK: 1 }
+                env: { HOMEBREW_NO_AUTO_UPDATE: 1, NONINTERACTIVE: 1 }
             });
             return status === SpawnStatus.SUCCESS;
         }

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

@@ -0,0 +1,12 @@
+import { ResourceConfig, StringIndexedObject } from 'codify-schemas';
+export declare function splitUserConfig<T extends StringIndexedObject>(config: ResourceConfig & T): {
+    parameters: T;
+    coreParameters: ResourceConfig;
+};
+export declare function setsEqual(set1: Set<unknown>, set2: Set<unknown>): boolean;
+export declare function untildify(pathWithTilde: string): string;
+export declare function tildify(pathWithTilde: string): string;
+export declare function resolvePathWithVariables(pathWithVariables: string): string;
+export declare function addVariablesToPath(pathWithoutVariables: string): string;
+export declare function unhome(pathWithHome: string): string;
+export declare function areArraysEqual(isElementEqual: ((desired: unknown, current: unknown) => boolean) | undefined, desired: unknown, current: unknown): boolean;

package/dist/utils/internal-utils.js

@@ -0,0 +1,74 @@
+import os from 'node:os';
+import path from 'node:path';
+export function splitUserConfig(config) {
+    const coreParameters = {
+        type: config.type,
+        ...(config.name ? { name: config.name } : {}),
+        ...(config.dependsOn ? { dependsOn: config.dependsOn } : {}),
+    };
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const { type, name, dependsOn, ...parameters } = config;
+    return {
+        parameters: parameters,
+        coreParameters,
+    };
+}
+export function setsEqual(set1, set2) {
+    return set1.size === set2.size && [...set1].every((v) => set2.has(v));
+}
+const homeDirectory = os.homedir();
+export function untildify(pathWithTilde) {
+    return homeDirectory ? pathWithTilde.replace(/^~(?=$|\/|\\)/, homeDirectory) : pathWithTilde;
+}
+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) {
+    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) {
+    return pathWithHome.includes('$HOME') ? pathWithHome.replaceAll('$HOME', os.homedir()) : pathWithHome;
+}
+export function areArraysEqual(isElementEqual, desired, current) {
+    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/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;