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

package/dist/utils/spawn.js

@@ -1,124 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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;

package/dist/utils/utils.js

@@ -1,86 +0,0 @@
-import os from 'node:os';
-import path from 'node:path';
-export const VerbosityLevel = new class {
-    level = 0;
-    get() {
-        return this.level;
-    }
-    set(level) {
-        this.level = level;
-    }
-};
-export function isDebug() {
-    return process.env.DEBUG != null && process.env.DEBUG.includes('codify'); // TODO: replace with debug library
-}
-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;
-}