@codifycli/plugin-core 1.0.0-beta1

package/dist/utils/index.js

@@ -0,0 +1,271 @@
+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
+}
+export var Shell;
+(function (Shell) {
+    Shell["ZSH"] = "zsh";
+    Shell["BASH"] = "bash";
+    Shell["SH"] = "sh";
+    Shell["KSH"] = "ksh";
+    Shell["CSH"] = "csh";
+    Shell["FISH"] = "fish";
+})(Shell || (Shell = {}));
+export const Utils = {
+    getUser() {
+        return os.userInfo().username;
+    },
+    getSystemInfo() {
+        return {
+            os: os.type(),
+            shell: this.getShell(),
+        };
+    },
+    isMacOS() {
+        return os.platform() === 'darwin';
+    },
+    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')) {
+            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() {
+        return this.getShellRcFiles()[0];
+    },
+    getShellRcFiles() {
+        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) {
+        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', 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) {
+        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() {
+        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/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;

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);
+}

package/dist/utils/pty-local-storage.d.ts

@@ -0,0 +1,2 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+export declare const ptyLocalStorage: AsyncLocalStorage<unknown>;

package/dist/utils/pty-local-storage.js

@@ -0,0 +1,2 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+export const ptyLocalStorage = new AsyncLocalStorage();

package/dist/utils/spawn-2.d.ts

@@ -0,0 +1,5 @@
+import { Shell } from 'zx';
+export declare class ShellContext implements Shell {
+    zx: Shell;
+    static create(): ShellContext;
+}

package/dist/utils/spawn-2.js

@@ -0,0 +1,7 @@
+import { $ } from 'zx';
+export class ShellContext {
+    zx = $({ shell: true });
+    static create() {
+        return new ShellContext();
+    }
+}

package/dist/utils/spawn.d.ts

@@ -0,0 +1,29 @@
+/// <reference types="node" resolution-mode="require"/>
+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;
+} & 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 $(cmd: string, opts?: CodifySpawnOptions): Promise<SpawnResult>;
+export declare function isDebug(): boolean;
+export {};

package/dist/utils/spawn.js

@@ -0,0 +1,124 @@
+import { Ajv } from 'ajv';
+import { MessageCmd, SudoRequestResponseDataSchema } from 'codify-schemas';
+import { spawn } from 'node:child_process';
+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 $(cmd, opts) {
+    const throws = opts?.throws ?? true;
+    console.log(`Running command: ${cmd}`);
+    try {
+        // TODO: Need to benchmark the effects of using sh vs zsh for shell.
+        //  Seems like zsh shells run slower
+        let result;
+        if (!opts?.requiresRoot) {
+            result = await internalSpawn(cmd, opts ?? {});
+        }
+        else {
+            result = await externalSpawnWithSudo(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);
+        }
+        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: error + '',
+        };
+    }
+}
+async function internalSpawn(cmd, opts) {
+    return new Promise((resolve, reject) => {
+        const output = [];
+        // Source start up shells to emulate a users environment vs. a non-interactive non-login shell script
+        // Ignore all stdin
+        const _process = spawn(`source ~/.zshrc; ${cmd}`, [], {
+            ...opts,
+            stdio: ['ignore', 'pipe', 'pipe'],
+            shell: 'zsh',
+        });
+        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) {
+            stdout.pipe(process.stdout);
+            stderr.pipe(process.stderr);
+        }
+        _process.on('close', (code) => {
+            resolve({
+                status: code === 0 ? SpawnStatus.SUCCESS : SpawnStatus.ERROR,
+                data: output.join('\n'),
+            });
+        });
+    });
+}
+async function externalSpawnWithSudo(cmd, opts) {
+    return await new Promise((resolve) => {
+        const listener = (data) => {
+            if (data.cmd === MessageCmd.SUDO_REQUEST + '_Response') {
+                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 ?? {},
+            }
+        });
+    });
+}
+export function isDebug() {
+    return process.env.DEBUG != null && process.env.DEBUG.includes('codify'); // TODO: replace with debug library
+}

package/dist/utils/utils.d.ts

@@ -0,0 +1,18 @@
+import { ResourceConfig, StringIndexedObject } from 'codify-schemas';
+export declare const VerbosityLevel: {
+    level: number;
+    get(): number;
+    set(level: number): void;
+};
+export declare function isDebug(): boolean;
+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;