@nu-art/commando 0.204.87 → 0.204.89

package/shell/interactive/CommandoInteractive.js

@@ -0,0 +1,180 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandoInteractive = void 0;
+const ts_common_1 = require("@nu-art/ts-common");
+const InteractiveShell_1 = require("./InteractiveShell");
+const BaseCommando_1 = require("../core/BaseCommando");
+class CommandoInteractive extends BaseCommando_1.BaseCommando {
+    /**
+     * Creates a new instance of CommandoInteractive merged with the provided plugins.
+     * @param {Constructor<any>[]} plugins - The plugins to merge with CommandoInteractive.
+     * @returns {CommandoInteractive} - The new instance of CommandoInteractive merged with the plugins.
+     */
+    static create(...plugins) {
+        const _commando = BaseCommando_1.BaseCommando._create(CommandoInteractive, ...plugins);
+        const commando = _commando;
+        commando.shell = new InteractiveShell_1.InteractiveShell();
+        commando.shell.setMinLevel(ts_common_1.LogLevel.Verbose);
+        return commando;
+    }
+    /**
+     * Constructs a CommandoInteractive instance.
+     */
+    constructor() {
+        super();
+        this.shell = new InteractiveShell_1.InteractiveShell();
+    }
+    /**
+     * Toggles or sets the debug mode.
+     * @param {boolean} [debug] - If provided, sets the debug mode to this value. Otherwise, toggles the current debug mode.
+     * @returns {boolean} - The current state of debug mode.
+     */
+    debug(debug) {
+        this.shell.debug(debug);
+        return super.debug(debug);
+    }
+    /**
+     * Sets the UID for the shell.
+     * @param {string} uid - The UID to set.
+     * @returns {this} - The CommandoInteractive instance for method chaining.
+     */
+    setUID(uid) {
+        this.shell.setUID(uid);
+        return this;
+    }
+    /**
+     * Closes the shell, optionally with a callback function.
+     * @returns {this} - The CommandoInteractive instance for method chaining.
+     */
+    close() {
+        return this.shell.endInteractive();
+    }
+    /**
+     * Kills the shell process with a given signal.
+     * @param {NodeJS.Signals | number} [signal] - The signal to send to the process.
+     * @returns {boolean} - Whether the kill signal was successfully sent.
+     */
+    kill(signal) {
+        return this.shell.kill(signal);
+    }
+    /**
+     * Gracefully kills a process by its PID.
+     * @param {number} [pid] - The PID of the process to kill.
+     */
+    async gracefullyKill(pid) {
+        return this.shell.gracefullyKill(pid);
+    }
+    /**
+     * Waits for a log entry that matches a specified pattern, then executes a callback.
+     * @param {string | RegExp} filter - The pattern to match in log entries.
+     * @param {(match: RegExpMatchArray) => any} callback - The callback to execute when a match is found.
+     */
+    onLog(filter, callback) {
+        const regexp = typeof filter === 'string' ? new RegExp(filter) : filter;
+        const pidLogProcessor = (log) => {
+            const match = log.match(regexp);
+            if (!match)
+                return true;
+            callback(match);
+            return true;
+        };
+        this.addLogProcessor(pidLogProcessor);
+    }
+    /**
+     * Executes commands asynchronously and listens for the PID.
+     *
+     * @param {Function} pidListener - A listener function to handle the PID.
+     * @param {Function} [callback] - A callback function to handle the command output.
+     * @returns {Promise<T>} - The result of the callback function.
+     */
+    async executeAsync(pidListener, callback) {
+        const uniqueFunctionName = (0, ts_common_1.generateHex)(16);
+        const pidUniqueKey = (0, ts_common_1.generateHex)(16);
+        const regexp = new RegExp(`${pidUniqueKey}=(\\d+)`);
+        const functionContent = this.builder.reset();
+        const functionName = `${uniqueFunctionName}() {`;
+        const pidLogProcessor = (log) => {
+            const match = log.match(regexp);
+            if (!match)
+                return true;
+            const pid = +match[1];
+            pidListener(pid);
+            return false;
+        };
+        return await this
+            .append(functionName)
+            .append(functionContent)
+            .append('}')
+            .append(`${uniqueFunctionName} &`)
+            .append('pid=$!')
+            .append(`echo "${pidUniqueKey}=\${pid}"`)
+            .append(`wait \$pid`)
+            .addLogProcessor(pidLogProcessor)
+            .execute(callback);
+    }
+    /**
+     * Executes commands and processes logs to extract exit code.
+     * @param {Function} [callback] - A callback function to handle the command output.
+     * @returns {Promise<T>} - The result of the callback function.
+     */
+    async execute(callback) {
+        return await new Promise((resolve, reject) => {
+            const uniqueKey = (0, ts_common_1.generateHex)(16);
+            const regexp = new RegExp(`${uniqueKey}=(\\d+)`);
+            let _stderr = '';
+            let _stdout = '';
+            const logProcessor = (log, type) => {
+                if (type === 'err')
+                    _stderr += `${log}\n`;
+                else
+                    _stdout += `${log}\n`;
+                if (!log.includes(uniqueKey))
+                    return true;
+                const match = log.match(regexp);
+                if (!match)
+                    return true;
+                const exitCode = match === null || match === void 0 ? void 0 : match[1];
+                this.removeLogProcessor(logProcessor);
+                try {
+                    resolve(callback === null || callback === void 0 ? void 0 : callback(_stdout, _stderr, +exitCode));
+                }
+                catch (err) {
+                    reject(err);
+                }
+                return false;
+            };
+            this.builder.append(`echo ${uniqueKey}=$?`);
+            const command = this.builder.reset();
+            this.shell.addLogProcessor(logProcessor);
+            this.shell.execute(command);
+        });
+    }
+    /**
+     * Adds a log processor to the shell.
+     * @param {Function} processor - The log processor function to add.
+     * @returns {this} - The CommandoInteractive instance for method chaining.
+     */
+    addLogProcessor(processor) {
+        this.shell.addLogProcessor(processor);
+        return this;
+    }
+    /**
+     * Removes a log processor from the shell.
+     * @param {Function} processor - The log processor function to remove.
+     * @returns {this} - The CommandoInteractive instance for method chaining.
+     */
+    removeLogProcessor(processor) {
+        this.shell.removeLogProcessor(processor);
+        return this;
+    }
+    /**
+     * Appends a command to the command list.
+     * @param {string} command - The command to append.
+     * @returns {this} - The CommandoInteractive instance for method chaining.
+     */
+    append(command) {
+        this.builder.append(command);
+        return this;
+    }
+}
+exports.CommandoInteractive = CommandoInteractive;

package/shell/interactive/InteractiveShell.d.ts

@@ -0,0 +1,63 @@
+/// <reference types="mocha" />
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import { Logger } from '@nu-art/ts-common';
+import { LogTypes } from '../types';
+export declare class InteractiveShell extends Logger {
+    private _debug;
+    private logProcessors;
+    private shell;
+    private alive;
+    /**
+     * Constructs an InteractiveShell instance, initializes a detached shell session, and sets up log processors.
+     */
+    constructor();
+    /**
+     * Toggles or sets the debug mode.
+     * @param {boolean} [debug] - If provided, sets the debug mode to this value. Otherwise, toggles the current debug mode.
+     * @returns {boolean} - The current state of debug mode.
+     */
+    debug(debug?: boolean): this;
+    /**
+     * Executes a command in the interactive shell.
+     * @param {string} command - The command to execute.
+     */
+    execute: (command: string) => void;
+    /**
+     * Awaits for the end of the interactive shell session.
+     */
+    endInteractive: () => Promise<void>;
+    /**
+     * Sends a signal to terminate the shell process.
+     * @param {NodeJS.Signals | number} [signal] - The signal to send to the shell process.
+     * @returns {boolean | undefined} - The result of the kill operation.
+     */
+    kill: (signal?: NodeJS.Signals | number) => boolean | undefined;
+    /**
+     * Attempts to gracefully terminate the shell process.
+     * @param {number} [pid] - Process ID of the shell to terminate.
+     * @returns {Promise<void>} - Resolves when the shell process is gracefully killed.
+     */
+    gracefullyKill: (pid?: number) => Promise<void>;
+    /**
+     * Adds a log processor to handle log messages.
+     * @param {(log: string, std: LogTypes) => boolean} processor - The log processor function.
+     * @returns {this} - The InteractiveShell instance for method chaining.
+     */
+    addLogProcessor(processor: (log: string, std: LogTypes) => boolean): this;
+    /**
+     * Removes a log processor from handling log messages.
+     * @param {(log: string, std: LogTypes) => boolean} processor - The log processor function to remove.
+     * @returns {this} - The InteractiveShell instance for method chaining.
+     */
+    removeLogProcessor(processor: (log: string, std: LogTypes) => boolean): this;
+    /**
+     * Sets a unique identifier for the shell session.
+     * @param {string} uid - The unique identifier.
+     * @returns {this} - The InteractiveShell instance for method chaining.
+     */
+    setUID(uid: string): this;
+}

package/shell/interactive/InteractiveShell.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InteractiveShell = void 0;
+const ts_common_1 = require("@nu-art/ts-common");
+const node_child_process_1 = require("node:child_process");
+class InteractiveShell extends ts_common_1.Logger {
+    /**
+     * Constructs an InteractiveShell instance, initializes a detached shell session, and sets up log processors.
+     */
+    constructor() {
+        var _a, _b;
+        super();
+        this._debug = false;
+        this.logProcessors = [];
+        /**
+         * Executes a command in the interactive shell.
+         * @param {string} command - The command to execute.
+         */
+        this.execute = (command) => {
+            var _a;
+            if (this._debug)
+                this.logDebug(`executing: `, `"""\n${command}\n"""`);
+            (_a = this.shell.stdin) === null || _a === void 0 ? void 0 : _a.write(command + '\n', 'utf-8', (err) => {
+                if (err)
+                    this.logError(`error`, err);
+            });
+        };
+        /**
+         * Awaits for the end of the interactive shell session.
+         */
+        this.endInteractive = () => {
+            return new Promise(resolve => {
+                var _a;
+                (_a = this.shell.stdin) === null || _a === void 0 ? void 0 : _a.end(resolve);
+            });
+        };
+        /**
+         * Sends a signal to terminate the shell process.
+         * @param {NodeJS.Signals | number} [signal] - The signal to send to the shell process.
+         * @returns {boolean | undefined} - The result of the kill operation.
+         */
+        this.kill = (signal) => {
+            if (!this.alive)
+                return;
+            return this.shell.kill(signal);
+        };
+        /**
+         * Attempts to gracefully terminate the shell process.
+         * @param {number} [pid] - Process ID of the shell to terminate.
+         * @returns {Promise<void>} - Resolves when the shell process is gracefully killed.
+         */
+        this.gracefullyKill = async (pid) => {
+            if (!this.alive)
+                return;
+            return new Promise((resolve, reject) => {
+                console.log('Killing process');
+                this.shell.on('exit', async (code, signal) => {
+                    console.log(`Process Killed ${signal}`);
+                    resolve();
+                });
+                if (pid) {
+                    console.log(`KILLING PID: ${pid}`);
+                    process.kill(pid, 'SIGINT');
+                }
+                else {
+                    console.log(`KILLING SHELL WITH SIGINT`);
+                    this.shell.kill('SIGINT');
+                }
+            });
+        };
+        this.shell = (0, node_child_process_1.spawn)('/bin/bash', {
+            detached: true,
+            shell: true
+        });
+        this.alive = true;
+        const printer = (std) => (data) => {
+            const messages = data.toString().trim().split('\n');
+            if (!messages.length)
+                return;
+            for (const message of messages) {
+                try {
+                    const toPrint = this.logProcessors.length === 0 || this.logProcessors.reduce((toPrint, processor) => {
+                        const filter = processor(message, std);
+                        return toPrint && filter;
+                    }, true);
+                    if (toPrint)
+                        this.logInfo(`${message}`);
+                }
+                catch (e) {
+                    this.logError(e);
+                }
+            }
+        };
+        (_a = this.shell.stdout) === null || _a === void 0 ? void 0 : _a.on('data', printer('out'));
+        (_b = this.shell.stderr) === null || _b === void 0 ? void 0 : _b.on('data', printer('err'));
+        // Handle shell exit
+        this.shell.on('close', (code) => {
+            this.alive = false;
+            this.logInfo(`child process exited with code ${code}`);
+        });
+    }
+    /**
+     * Toggles or sets the debug mode.
+     * @param {boolean} [debug] - If provided, sets the debug mode to this value. Otherwise, toggles the current debug mode.
+     * @returns {boolean} - The current state of debug mode.
+     */
+    debug(debug) {
+        this._debug = debug !== null && debug !== void 0 ? debug : !this._debug;
+        return this;
+    }
+    /**
+     * Adds a log processor to handle log messages.
+     * @param {(log: string, std: LogTypes) => boolean} processor - The log processor function.
+     * @returns {this} - The InteractiveShell instance for method chaining.
+     */
+    addLogProcessor(processor) {
+        this.logProcessors.push(processor);
+        return this;
+    }
+    /**
+     * Removes a log processor from handling log messages.
+     * @param {(log: string, std: LogTypes) => boolean} processor - The log processor function to remove.
+     * @returns {this} - The InteractiveShell instance for method chaining.
+     */
+    removeLogProcessor(processor) {
+        (0, ts_common_1.removeItemFromArray)(this.logProcessors, processor);
+        return this;
+    }
+    /**
+     * Sets a unique identifier for the shell session.
+     * @param {string} uid - The unique identifier.
+     * @returns {this} - The InteractiveShell instance for method chaining.
+     */
+    setUID(uid) {
+        this.setTag(uid);
+        return this;
+    }
+}
+exports.InteractiveShell = InteractiveShell;

package/shell/simple/Commando.d.ts

@@ -0,0 +1,17 @@
+import { Constructor } from '@nu-art/ts-common';
+import { BaseCommando } from '../core/BaseCommando';
+export declare class Commando extends BaseCommando {
+    private uid?;
+    static create<T extends Constructor<any>[]>(...plugins: T): import("../core/class-merger").MergeTypes<[typeof BaseCommando, typeof Commando, ...T]> & BaseCommando & Commando;
+    constructor();
+    setUID(uid: string): this;
+    executeFile(filePath: string, interpreter?: string): Promise<{
+        stdout: string;
+        stderr: string;
+    }>;
+    executeRemoteFile(pathToFile: string, interpreter: string): Promise<{
+        stdout: string;
+        stderr: string;
+    }>;
+    execute<T>(callback?: (stdout: string, stderr: string, exitCode: number) => T): Promise<T | void>;
+}

package/shell/simple/Commando.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Commando = void 0;
+const ts_common_1 = require("@nu-art/ts-common");
+const SimpleShell_1 = require("./SimpleShell");
+const BaseCommando_1 = require("../core/BaseCommando");
+const CliError_1 = require("../core/CliError");
+class Commando extends BaseCommando_1.BaseCommando {
+    static create(...plugins) {
+        const _commando = BaseCommando_1.BaseCommando._create(Commando, ...plugins);
+        return _commando;
+    }
+    constructor() {
+        super();
+    }
+    setUID(uid) {
+        this.uid = uid;
+        return this;
+    }
+    executeFile(filePath, interpreter) {
+        let command = filePath;
+        // If an interpreter is provided, prefix the command with it.
+        if (interpreter) {
+            command = `${interpreter} ${filePath}`;
+        }
+        return new SimpleShell_1.SimpleShell().execute(command);
+    }
+    executeRemoteFile(pathToFile, interpreter) {
+        const command = `curl -o- "${pathToFile}" | ${interpreter}`;
+        return new SimpleShell_1.SimpleShell().execute(command);
+    }
+    async execute(callback) {
+        var _a;
+        const command = this.builder.reset();
+        const simpleShell = new SimpleShell_1.SimpleShell().debug(this._debug);
+        try {
+            if (this.uid)
+                simpleShell.setUID(this.uid);
+            const { stdout, stderr } = await simpleShell.execute(command);
+            return callback === null || callback === void 0 ? void 0 : callback(stdout, stderr, 0);
+        }
+        catch (_error) {
+            simpleShell.logError(_error);
+            const cliError = _error;
+            if ('isInstanceOf' in cliError && cliError.isInstanceOf(CliError_1.CliError))
+                return callback === null || callback === void 0 ? void 0 : callback(cliError.stdout, cliError.stderr, (_a = cliError.cause.code) !== null && _a !== void 0 ? _a : -1);
+            throw new ts_common_1.ThisShouldNotHappenException('Unhandled error', _error);
+        }
+    }
+}
+exports.Commando = Commando;

package/shell/simple/SimpleShell.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { ExecOptions } from 'child_process';
+import { Logger } from '@nu-art/ts-common';
+export type CliOptions = ExecOptions & {
+    encoding: BufferEncoding | string | null;
+};
+export declare class SimpleShell extends Logger {
+    private _debug;
+    private cliOptions;
+    /**
+     * Executes the accumulated commands in the command list.
+     * @returns {Promise<string>} A promise that resolves with the standard output of the executed command.
+     */
+    execute: (command: string) => Promise<{
+        stdout: string;
+        stderr: string;
+    }>;
+    debug(debug?: boolean): this;
+    setShell(shell: string): void;
+    setOptions(options: Partial<CliOptions>): void;
+    setUID(uid: string): this;
+}

package/shell/simple/SimpleShell.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SimpleShell = void 0;
+const child_process_1 = require("child_process");
+const ts_common_1 = require("@nu-art/ts-common");
+const CliError_1 = require("../core/CliError");
+class SimpleShell extends ts_common_1.Logger {
+    constructor() {
+        super(...arguments);
+        this._debug = false;
+        this.cliOptions = { shell: '/bin/bash' };
+        /**
+         * Executes the accumulated commands in the command list.
+         * @returns {Promise<string>} A promise that resolves with the standard output of the executed command.
+         */
+        this.execute = async (command) => {
+            if (this._debug)
+                this.logDebug(`executing: `, `"""\n${command}\n"""`);
+            return new Promise((resolve, reject) => {
+                (0, child_process_1.exec)(command, this.cliOptions, (error, stdout, stderr) => {
+                    if (error) {
+                        return reject(new CliError_1.CliError(`executing:\n${command}\n`, stdout, stderr, error));
+                    }
+                    if (stdout)
+                        this.logInfo(stdout);
+                    if (stderr)
+                        this.logError(stderr);
+                    resolve({ stdout, stderr });
+                });
+            });
+        };
+    }
+    debug(debug) {
+        this._debug = debug !== null && debug !== void 0 ? debug : !this._debug;
+        return this;
+    }
+    setShell(shell) {
+        (this.cliOptions || (this.cliOptions = {})).shell = shell;
+    }
+    setOptions(options) {
+        this.cliOptions = options;
+    }
+    setUID(uid) {
+        this.setTag(uid);
+        return this;
+    }
+}
+exports.SimpleShell = SimpleShell;

package/shell/types.d.ts

@@ -0,0 +1,3 @@
+import { BaseCommando } from './core/BaseCommando';
+export type LogTypes = 'out' | 'err';
+export type CliBlock<Commando extends BaseCommando> = (cli: Commando) => void;

package/shell/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cli/cli-params.d.ts

@@ -1,56 +0,0 @@
-import { Primitive, TypeOfTypeAsString } from '@nu-art/ts-common';
-export declare const DefaultProcessor_Boolean: CliParam<any, boolean>['process'];
-export declare const DefaultProcessor_String: CliParam<any, string>['process'];
-export declare const DefaultProcessor_Number: CliParam<any, number>['process'];
-export type CliParams<T extends BaseCliParam<string, any>[]> = {
-    [K in T[number]['keyName']]: NonNullable<Extract<T[number], {
-        keyName: K;
-    }>['defaultValue']>;
-};
-export type DependencyParam<T extends Primitive | Primitive[]> = {
-    param: BaseCliParam<string, T>;
-    value: T;
-};
-export type BaseCliParam<K extends string, V extends Primitive | Primitive[]> = {
-    keys: string[];
-    keyName: K;
-    type: TypeOfTypeAsString<V>;
-    description: string;
-    name?: string;
-    options?: string[];
-    defaultValue?: V;
-    process?: (value?: string, defaultValue?: V) => V;
-    isArray?: true;
-    group?: string;
-    dependencies?: DependencyParam<any>[];
-};
-export type CliParam<K extends string, V extends Primitive | Primitive[]> = BaseCliParam<K, V> & {
-    name: string;
-    process: (value?: string, defaultValue?: V) => V;
-};
-export declare class CLIParams_Resolver<T extends BaseCliParam<string, any>[], Output extends CliParams<T> = CliParams<T>> {
-    private params;
-    static create<T extends BaseCliParam<string, any>[]>(...params: T): CLIParams_Resolver<T, CliParams<T>>;
-    constructor(params: BaseCliParam<string, any>[]);
-    /**
-     * Format current input params and return it structured by the app params type.
-     * @param inputParams current console input arguments
-     * @returns CliParamsObject
-     */
-    resolveParamValue(inputParams?: string[]): Output;
-    /**
-     * Find the matching param by finding it's key in the current argument
-     * Go over the app params and find the CLIParam object representing it
-     * @param inputParam The current console argument being parsed
-     * @returns The CliParam or undefined if not found
-     * @private
-     */
-    private findMatchingParamToResolve;
-    /**
-     * Translate BaseCLIParams passed to the constructor to CLIParams
-     * @param params User input of CLI params being passed to the constructor
-     * @private
-     * @returns CLI Params filled with all mandatory data
-     */
-    private translate;
-}

package/core/CliError.d.ts

@@ -1,6 +0,0 @@
-export declare class CliError extends Error {
-    stdout: string;
-    stderr: string;
-    cause?: Error;
-    constructor(message: string, stdout: string, stderr: string, cause?: Error);
-}

package/core/CliError.js

@@ -1,12 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CliError = void 0;
-class CliError extends Error {
-    constructor(message, stdout, stderr, cause) {
-        super(message);
-        this.stdout = stdout;
-        this.stderr = stderr;
-        this.cause = cause;
-    }
-}
-exports.CliError = CliError;

package/core/class-merger.d.ts

@@ -1,5 +0,0 @@
-type Constructor<T = {}> = new (...args: any[]) => T;
-export type MergeTypes<T extends Constructor<any>[]> = T extends [a: Constructor<infer A>, ...rest: infer R] ? R extends Constructor<any>[] ? A & MergeTypes<R> : {} : {};
-export declare function MergeClass<T extends Constructor<any>[]>(...plugins: T): Constructor<MergeTypes<T>>;
-export declare function CreateMergedInstance<T extends Constructor<any>[]>(...plugins: T): MergeTypes<T>;
-export {};