node-sys/src/index.ts

Universal package installer, get the command for managing packages, or auto install any package, using one command for all platforms. Automate the installation of macOS Brew, and Windows Chocolatey package managers. A promisify child process of spawn, and

import which from 'which';
import {
    spawn,
    fork,
    SpawnOptionsWithoutStdio,
    ChildProcess,
    ChildProcessWithoutNullStreams,
    Serializable,
} from 'child_process';
import { dirname, join } from 'path';
import { fileURLToPath } from 'url';
import { createRequire } from 'module';
import { Blob } from 'buffer';
import { Stream } from 'stream';

const __filename = fileURLToPath(import.meta.url);

const __dirname = dirname(__filename);

/**
 * Like the unix `which` utility.
 *
 * Finds the first instance of a specified executable in the PATH environment variable.
 *
 * @param String executable
 *
 * @returns String|Null
 */
export const where = (Sys.where = function (executable: string) {
    let found = which.sync(executable, {
        nothrow: true,
    });
    return found;
});

// use sudo if installed (e.g. it might not be required in a Docker containers)
const sudo = where('sudo') !== null ? 'sudo' : '';

/**
 * Supported package commands
 */
const SYS_COMMANDS = {
    brew: 'brew install',
    port: `${sudo} port install`,
    pkgin: `${sudo} pkgin install`,
    winget: 'winget install',
    choco: 'choco install',
    powershell:
        "powershell 'Set-ExecutionPolicy Bypass -Scope Process -Force; iex ((New-Object System.Net.WebClient).DownloadString('https://chocolatey.org/install.ps1'))'",
    'apt-get': `${sudo} apt-get install`,
    yum: `${sudo} yum install`,
    dnf: `${sudo} dnf install`,
    nix: 'nix-env --install',
    zypper: `${sudo} zypper in`,
    emerge: `${sudo} emerge -a`,
    pacman: `${sudo} pacman -S`,
    pkg: 'pkg install',
    pkg_add: 'pkg_add',
    crew: 'crew install',
} as Record<string, string>;

/**
 * Supported package managers
 */
const SYS_MANAGERS = {
    darwin: ['brew', 'port', 'pkgin'],
    win32: ['winget', 'choco', 'powershell'],
    linux: [
        'apt-get',
        'yum',
        'dnf',
        'nix',
        'zypper',
        'emerge',
        'pacman',
        'crew',
    ],
    freebsd: ['pkg', 'pkg_add'],
    sunos: ['pkg'],
    netbsd: ['none'],
    win64: ['choco'],
    shell: ['powershell'],
} as Record<string, string[]>;

function Sys() {}

function sysManager(): string | string[] {
    let managers = SYS_MANAGERS[process.platform];

    if (!managers || !managers.length) {
        return "unknown platform '" + process.platform + "'";
    }

    managers = managers.filter(function (mng) {
        return where(mng) !== null;
    });

    if (!managers.length) {
        return 'System OS package manager not found';
    }

    return SYS_COMMANDS[managers[0]].trimStart().split(' ');
}

/**
 * Gets the system package manager install command.
 *
 * @returns {Object}
 *```
 * sudo: boolean, // true or false,
 * command: string, // 'apk-get' - system package manager command,
 * installer: string, // 'sudo apk-get install' - full install command
 *```
 * - Defaults to 'get os-manager installer' if no package manager is found.
 *
 * @throws if `process.platform` is none of darwin, freebsd, linux, sunos or win32.
 */
export const packager = (Sys.packager = function (): object | Error {
    let sys = sysManager();
    if (isArray(sys) && sys[0])
        return {
            sudo: sys[0].endsWith('sudo'),
            command: !sys[2] ? sys[0] : sys[1],
            installer: sys.join(' '),
        };
    else return new Error(sys as string);
});

/**
 * Install package using the system package manager command.
 *
 * @param {String|Array} application package to install.
 * @param {Function} progress callback for any output doing installation.
 * - Any value returned in `callback` will be the final resolved result.
 *
 * @returns {Promise} Promise Output of spawn command.
 * - E.g. 'sudo apg-get install' for Debian based systems.
 * - Defaults to 'get os-manager installer' if no package manager is found.
 * @rejects On any spawn error, or if `process.platform` is none of
 * darwin, freebsd, linux, sunos or win32.
 */
export const installer = (Sys.installer = function (
    application: string | string[],
    progress: Function
): Promise<any> {
    if (!application)
        return new Promise((_resolve, reject) => {
            return reject('No package, application name missing.');
        });
    let manager = sysManager();
    if (!isArray(manager))
        return new Promise((_resolve, reject) => {
            return reject(manager);
        });
    let cmd = manager[0];
    let args: string[] | null = null;
    let install: string[] | null = null;
    if (manager[1]) args = [manager[1]];
    if (manager[2]) install = [manager[2]];
    let silentCmd = isWindows()
        ? ['--accept-package-agreements', '--accept-source-agreements', '-h']
        : ['-y'];
    let whatToInstall: string[] = isArray(application)
        ? application.concat(silentCmd)
        : [application].concat(silentCmd);
    let system = whatToInstall;
    if (args && !install) system = args.concat(whatToInstall);
    else if (args && install)
        system = args.concat(install).concat(whatToInstall);

    if (cmd != 'powershell') {
        if (cmd.includes('choco') && isWindows()) {
            cmd = where('choco') ?? 'choco';
            system = [cmd].concat(system);
            cmd = join(__dirname, '..', 'bin', 'sudo.bat');
        }

        return spawning(cmd, system, progress);
    } else {
        return new Promise((_resolve, reject) => {
            return reject('No package manager installed!');
        });
    }
});

export type SpawningOnProgress = (args: {
    spawn: ChildProcessWithoutNullStreams;
    output: any;
    fork: ChildProcess | null;
}) => string | string[] | null;

export type SpawningOnError = (err: string) => Error | string;

export type SpawningOnMessage = (data: Serializable) => void;

export type SpawningOptions = SpawnOptionsWithoutStdio & {
    sudo?: boolean;
    fork?: boolean | null;
    onerror?: null | SpawningOnError;
    onprogress?: null | SpawningOnProgress;
    onmessage?: null | SpawningOnMessage;
};

/**
 * Spawn subprocess with `Promise` features, pass callbacks for `.on('data')` events, with ability to run as admin.
 *
 * @param {String} command - platform command
 * @param {Array} argument - command arguments
 * @param {Function|Object} progressOptions - either callback for `stdout.on('data')` event or `options`.
 * - the callback will receive an object:
 *```js
 * spawn: object, // child process **spawn** `instance`.
 * output: string, // any **output** data.
 * fork: object, // if created, child process **fork** `instance`.
 *```
 * - any `return` is the **`resolve()` .then()** result.
 * @param {Object} options - Any child process `spawn` options, defaults: stdio: 'pipe'.
 * - Additionally:
 *```js
 * sudo: boolean, // run as administrator.
 * fork: string, //  execute an additional module, a child_process.`fork` IPC communication channel.
 * onerror: callable, // callback for `stderr.on('data')` event.
 * onprogress: callable, // callback for `stdout.on('data')` event.
 * onmessage: callable, // callback for `on('message')` for `fork` event.
 *```
 */
export const spawning = (Sys.spawning = function (
    command: string,
    argument: Array<string>,
    progressOptions: SpawningOnProgress | object,
    options?: SpawningOptions | undefined
): Promise<string | string[] | null> {
    return new Promise<string | string[] | null>((resolve, reject) => {
        options = options || {
            stdio: 'pipe',
            sudo: false,
            fork: null,
            onerror: null,
            onprogress: null,
            onmessage: null,
        };
        options.stdio = options.stdio || 'pipe';
        const forked = isString(options.fork) ? fork(options.fork) : null;
        let progress = progressOptions;
        if (isObjectOnly(progressOptions))
            options = Object.assign(options, progressOptions);
        if (isFunction(options.onprogress)) progress = options.onprogress;
        let error: Error | string | null = null;
        let output: string | string[] | null = null;
        let isSudo = options.sudo || false;
        let onerror = options.onerror || null;
        let onmessage = options.onmessage || null;
        delete options.sudo;
        delete options.fork;
        delete options.onerror;
        delete options.onprogress;
        delete options.onmessage;

        if (isSudo) {
            argument = [command].concat(argument);

            // sudo
            if (isWindows()) {
                command = join(__dirname, '..', 'bin', 'sudo.bat');
            } else {
                command = sudo;
            }
        }

        const spawned = spawn(command, argument, options);
        spawned.on('error', (data) => {
            return reject(data);
        });
        spawned.on('close', (code) => {
            if (code === 0) {
                return resolve(output);
            }

            return reject(error);
        });
        spawned.on('exit', (code) => {
            if (forked)
                setTimeout(() => {
                    forked.kill();
                }, 1000);

            if (code === 0) {
                return resolve(output);
            }

            return reject(error);
        });
        spawned.stdout.on('data', (data) => {
            let input: string = data.toString();
            output += input;

            try {
                if (isFunction(progress)) {
                    output =
                        progress({
                            spawn: spawned,
                            output: input,
                            fork: forked,
                        }) || output;
                }
            } catch (e) {
                return reject((e as Error).toString());
            }

            if (argument.includes('fake-js')) {
                spawned.kill('SIGKILL');
                return resolve('For testing only. ' + output);
            }
        });
        spawned.stderr.on('data', (data) => {
            let err: string = data.toString();
            error += err;
            if (isFunction(onerror))
                /* c8 ignore next */
                error = onerror(err) || error;
        });

        if (forked) {
            forked.on('message', (data) => {
                if (isFunction(onmessage)) onmessage(data);
            });
        }

        if (
            argument.includes('fake-js') &&
            Object.getOwnPropertyDescriptor(process, 'platform')?.value ==
                'darwin'
        ) {
            spawned.kill('SIGKILL');
            return resolve('For testing only. ' + output);
        }
    });
});
let toString = Object.prototype.toString;

/**
 * Determine if a value is an Array.
 *
 * @param {Object} value The value to test.
 * @returns {boolean} True if value is an Array, otherwise false.
 */
export const isArray = (Sys.isArray = Array.isArray);

/**
 * Determine if a value is undefined.
 *
 * @param {Object} value The value to test.
 * @returns {boolean} True if the value is undefined, otherwise false.
 */
export const isUndefined = (Sys.isUndefined = function (
    value: any
): value is undefined {
    return typeof value === 'undefined';
});

/**
 * Determine if a value is a Buffer.
 *
 * @param {Object} value The value to test.
 * @returns {boolean} True if value is a Buffer, otherwise false.
 */
export const isBuffer = (Sys.isBuffer = function (value: any): value is Buffer {
    return (
        value !== null &&
        !isUndefined(value) &&
        value.constructor !== null &&
        !isUndefined(value.constructor) &&
        typeof value.constructor.isBuffer === 'function' &&
        value.constructor.isBuffer(value)
    );
});

/**
 * Determine if a value is an ArrayBuffer.
 *
 * @param {Object} value The value to test.
 * @returns {boolean} True if value is an ArrayBuffer, otherwise false
 */
export const isArrayBuffer = (Sys.isArrayBuffer = function (
    value: any
): value is ArrayBuffer {
    return toString.call(value) === '[object ArrayBuffer]';
});

/**
 * Determine if a value is a String.
 *
 * @param {Object} value The value to test.
 * @returns {boolean} True if value is a String, otherwise false.
 */
export const isString = (Sys.isString = function (value: any): value is string {
    return typeof value === 'string';
});

/**
 * Determine if a value is a Number.
 *
 * @param {Object} value The value to test.
 * @returns {boolean} True if value is a Number, otherwise false.
 */
export const isNumber = (Sys.isNumber = function (value: any): value is number {
    return typeof value === 'number';
});

/**
 * Determine if a value is an Object
 *
 * @param {Object} value The value to test.
 * @returns {boolean} True if value is an Object, otherwise false.
 */
export const isObject = (Sys.isObject = function (value: any): value is object {
    return value !== null && typeof value === 'object';
});

/**
 * Determine if a value is only a Object, not an `Array` or `Function`.
 *
 * @param {Object} value The value to test.
 * @return {boolean} True if value is a `Object` only, otherwise false.
 */
export const isObjectOnly = (Sys.isObjectOnly = function (
    value: any
): value is object {
    if (toString.call(value) !== '[object Object]') {
        return false;
    }

    let prototype = Object.getPrototypeOf(value);
    return prototype === null || prototype === Object.prototype;
});

/**
 * Determine if a value is a Blob
 *
 * @param {Object} value The value to test
 * @returns {boolean} True if value is a Blob, otherwise false
 */
export const isBlob = (Sys.isBlob = function (value: any): value is Blob {
    return toString.call(value) === '[object Blob]';
});

/**
 * Determine if a value is a Function
 *
 * @param {Object} value The value to test
 * @returns {boolean} True if value is a Function, otherwise false
 */
export const isFunction = (Sys.isFunction = function (
    value: any
): value is Function {
    return toString.call(value) === '[object Function]';
});

/**
 * Determine if a value is a Date
 *
 * @param {Object} value The value to test
 * @returns {boolean} True if value is a Date, otherwise false
 */
export const isDate = (Sys.isDate = function (value: any): value is Date {
    return toString.call(value) === '[object Date]';
});

/**
 * Determine if a value is a Stream
 *
 * @param {Object} value The value to test
 * @returns {boolean} True if value is a Stream, otherwise false
 */
export const isStream = (Sys.isStream = function (value: any): value is Stream {
    return (
        isObject(value) &&
        'pipe' in value &&
        isFunction((value as { pipe: any }).pipe)
    );
});

/**
 * Determine if a value is a boolean
 *
 * @param {Object} value The value to test
 * @returns {boolean} True if value is a boolean, otherwise false
 */
export const isBool = (Sys.isBool = function (value: any): value is boolean {
    return value === true || value === false;
});

/**
 * Determine if a value is a null
 *
 * @param {Object} value The value to test
 * @returns {boolean} True if value is a null, otherwise false
 */
export const isNull = (Sys.isNull = function (value: any): value is null {
    return value === null;
});

/**
 * Determine if platform is Windows
 *
 * @returns {boolean} True if Windows OS, otherwise false
 */
export const isWindows = (Sys.isWindows = function (): boolean {
    return process.platform === 'win32';
});

/**
 * Determine if platform is Linux
 *
 * @returns {boolean} True if Linux OS, otherwise false
 */
export const isLinux = (Sys.isLinux = function (): boolean {
    return process.platform === 'linux';
});

/**
 * Determine if platform is Apple Mac
 *
 * @returns {boolean} True if Apple macOS, otherwise false
 */
export const isMac = (Sys.isMac = function (): boolean {
    return process.platform === 'darwin';
});

/**
 * Include an `CommonJS` module the old way.
 *
 * @param {string} module
 */
export const require = createRequire(import.meta.url);
export default Sys;
export const System = Sys;