@nu-art/commando 0.401.0 → 0.401.2

package/simple/Commando.js

@@ -0,0 +1,122 @@
+import { ThisShouldNotHappenException } from '@nu-art/ts-common';
+import { SimpleShell } from './SimpleShell.js';
+import { BaseCommando } from '../core/BaseCommando.js';
+import { CliError } from '../core/CliError.js';
+/**
+ * Simple shell command executor extending BaseCommando.
+ *
+ * Provides a straightforward way to build and execute shell commands
+ * using SimpleShell. Supports file execution and remote file execution.
+ *
+ * **Features**:
+ * - Command building via BaseCommando fluent API
+ * - File execution with optional interpreter
+ * - Remote file execution via curl
+ * - Error handling with CliError
+ * - UID tagging for log identification
+ *
+ * **Error Handling**:
+ * - Catches CliError and calls callback with error details
+ * - Throws ThisShouldNotHappenException for unexpected errors
+ * - Always calls callback (even on error) if provided
+ */
+export class Commando extends BaseCommando {
+    /** Optional unique identifier for log tagging */
+    uid;
+    /**
+     * Creates a Commando instance with plugins.
+     *
+     * @template T - Array of plugin constructor types
+     * @param plugins - Plugin classes to merge
+     * @returns Merged Commando instance with plugins
+     */
+    static create(...plugins) {
+        const _commando = BaseCommando._create(Commando, ...plugins);
+        return _commando;
+    }
+    constructor() {
+        super();
+    }
+    /**
+     * Sets a unique identifier for this commando instance.
+     *
+     * Used for log tagging to identify which commando instance
+     * generated log messages.
+     *
+     * @param uid - Unique identifier string
+     * @returns This instance for method chaining
+     */
+    setUID(uid) {
+        this.uid = uid;
+        return this;
+    }
+    /**
+     * Executes a local file with an optional interpreter.
+     *
+     * If an interpreter is provided, prefixes the file path with it.
+     * Otherwise executes the file directly (must be executable).
+     *
+     * @param filePath - Path to file to execute
+     * @param interpreter - Optional interpreter (e.g., 'node', 'python3')
+     * @returns Promise resolving to command output
+     */
+    executeFile(filePath, interpreter) {
+        let command = filePath;
+        // If an interpreter is provided, prefix the command with it.
+        if (interpreter) {
+            command = `${interpreter} ${filePath}`;
+        }
+        return new SimpleShell().execute(command);
+    }
+    /**
+     * Executes a remote file by downloading and piping to interpreter.
+     *
+     * Uses curl to download the file and pipes it directly to the interpreter.
+     * Does not save the file locally.
+     *
+     * **Security Note**: Executes remote code without verification.
+     *
+     * @param pathToFile - URL to remote file
+     * @param interpreter - Interpreter to execute the file (e.g., 'bash', 'node')
+     * @returns Promise resolving to command output
+     */
+    executeRemoteFile(pathToFile, interpreter) {
+        const command = `curl -o- "${pathToFile}" | ${interpreter}`;
+        return new SimpleShell().execute(command);
+    }
+    /**
+     * Executes the accumulated commands and optionally processes output.
+     *
+     * **Behavior**:
+     * - Resets the command builder (gets accumulated command)
+     * - Creates a new SimpleShell instance with debug mode
+     * - Executes the command
+     * - On success: calls callback with stdout, stderr, exitCode=0
+     * - On error: catches CliError, calls callback with error details, returns result
+     * - On unexpected error: throws ThisShouldNotHappenException
+     *
+     * **Note**: The callback is always called if provided, even on error.
+     * This allows handling errors without try/catch.
+     *
+     * @template T - Return type of callback
+     * @param callback - Optional function to process command output
+     * @returns Promise resolving to callback result or void
+     */
+    async execute(callback) {
+        const command = this.builder.reset();
+        const simpleShell = new SimpleShell().debug(this._debug);
+        try {
+            if (this.uid)
+                simpleShell.setUID(this.uid);
+            const { stdout, stderr } = await simpleShell.execute(command);
+            return callback?.(stdout, stderr, 0);
+        }
+        catch (_error) {
+            simpleShell.logError(_error);
+            const cliError = _error;
+            if ('isInstanceOf' in cliError && cliError.isInstanceOf(CliError))
+                return callback?.(cliError.stdout, cliError.stderr, cliError.cause.code ?? -1);
+            throw new ThisShouldNotHappenException('Unhandled error', _error);
+        }
+    }
+}

package/simple/SimpleShell.d.ts

@@ -0,0 +1,48 @@
+import { ExecOptions } from 'child_process';
+import { Logger } from '@nu-art/ts-common';
+/**
+ * Extended ExecOptions with encoding support.
+ */
+export type CliOptions = ExecOptions & {
+    encoding: BufferEncoding | string | null;
+};
+/**
+ * Simple shell command executor using Node.js child_process.
+ *
+ * Executes shell commands synchronously via `exec()` and handles
+ * output conversion. Supports debug logging and custom shell/options.
+ *
+ * **Behavior**:
+ * - Uses `/bin/bash` as default shell
+ * - Converts Buffer output to UTF-8 strings
+ * - Logs stdout as info, stderr as error
+ * - Throws CliError on command failure
+ * - Supports UID tagging for log identification
+ */
+export declare class SimpleShell extends Logger {
+    /** Debug mode flag (enables verbose command logging) */
+    private _debug;
+    /** Execution options for child_process.exec() */
+    private cliOptions;
+    /**
+     * Executes a shell command and returns stdout/stderr.
+     *
+     * **Behavior**:
+     * - Logs command in debug mode (wrapped in triple quotes)
+     * - Converts Buffer output to UTF-8 strings
+     * - Logs stdout as info, stderr as error
+     * - Throws CliError if command fails (non-zero exit code)
+     *
+     * @param command - Shell command string to execute
+     * @returns Promise resolving to stdout and stderr strings
+     * @throws CliError if command execution fails
+     */
+    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 → simple}/SimpleShell.js

@@ -1,6 +1,12 @@
 import { exec } from 'child_process';
 import { Logger } from '@nu-art/ts-common';
 import { CliError } from '../core/CliError.js';
+/**
+ * Converts input to string, handling Buffer and ArrayBufferLike types.
+ *
+ * @param input - String, Buffer, or ArrayBufferLike to convert
+ * @returns UTF-8 string representation
+ */
 function toStringWithNewlines(input) {
     if (typeof input === 'string')
         return input;
@@ -8,12 +14,36 @@ function toStringWithNewlines(input) {
         ? input.toString('utf8')
         : Buffer.from(input).toString('utf8');
 }
+/**
+ * Simple shell command executor using Node.js child_process.
+ *
+ * Executes shell commands synchronously via `exec()` and handles
+ * output conversion. Supports debug logging and custom shell/options.
+ *
+ * **Behavior**:
+ * - Uses `/bin/bash` as default shell
+ * - Converts Buffer output to UTF-8 strings
+ * - Logs stdout as info, stderr as error
+ * - Throws CliError on command failure
+ * - Supports UID tagging for log identification
+ */
 export class SimpleShell extends Logger {
+    /** Debug mode flag (enables verbose command logging) */
     _debug = false;
+    /** Execution options for child_process.exec() */
     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.
+     * Executes a shell command and returns stdout/stderr.
+     *
+     * **Behavior**:
+     * - Logs command in debug mode (wrapped in triple quotes)
+     * - Converts Buffer output to UTF-8 strings
+     * - Logs stdout as info, stderr as error
+     * - Throws CliError if command fails (non-zero exit code)
+     *
+     * @param command - Shell command string to execute
+     * @returns Promise resolving to stdout and stderr strings
+     * @throws CliError if command execution fails
      */
     execute = async (command) => {
         if (this._debug)

package/tools.d.ts

@@ -0,0 +1,33 @@
+import { AbsolutePath } from '@nu-art/ts-common';
+/**
+ * Removes ANSI escape codes from a string.
+ *
+ * Strips color codes and formatting sequences (e.g., `\x1B[31m` for red text)
+ * from shell command output. Useful for processing command output that
+ * contains terminal formatting.
+ *
+ * **Regex**: Matches ANSI escape sequences starting with `\x1B[` followed by
+ * digits, optional semicolon, more digits, and ending with `m`.
+ *
+ * @param text - Text containing ANSI escape codes
+ * @returns Text with all ANSI codes removed
+ */
+export declare function removeAnsiCodes(text: string): string;
+/**
+ * Converts a relative or absolute path to a full absolute path.
+ *
+ * **Behavior**:
+ * - Removes leading slashes (normalizes paths like `/path/to/file`)
+ * - Resolves relative to `assetParentPath` (defaults to `process.cwd()`)
+ * - Returns a branded `AbsolutePath` type
+ *
+ * **Note**: The commented-out validation that checks if the resolved path
+ * is within `assetParentPath` is disabled. This could be a security concern
+ * if used with user-provided paths.
+ *
+ * @param pathToFile - Path to convert (relative or absolute)
+ * @param assetParentPath - Base path for resolution (default: `process.cwd()`)
+ * @returns Absolute path as branded type
+ * @throws Error if path is not provided or is empty
+ */
+export declare function convertToFullPath(pathToFile: string, assetParentPath?: string): AbsolutePath;

package/tools.js

@@ -0,0 +1,47 @@
+import * as path from 'path';
+/**
+ * Removes ANSI escape codes from a string.
+ *
+ * Strips color codes and formatting sequences (e.g., `\x1B[31m` for red text)
+ * from shell command output. Useful for processing command output that
+ * contains terminal formatting.
+ *
+ * **Regex**: Matches ANSI escape sequences starting with `\x1B[` followed by
+ * digits, optional semicolon, more digits, and ending with `m`.
+ *
+ * @param text - Text containing ANSI escape codes
+ * @returns Text with all ANSI codes removed
+ */
+export function removeAnsiCodes(text) {
+    // This regular expression matches the escape codes and removes them
+    return text.replace(/\x1B\[\d+;?\d*m/g, '');
+}
+/**
+ * Converts a relative or absolute path to a full absolute path.
+ *
+ * **Behavior**:
+ * - Removes leading slashes (normalizes paths like `/path/to/file`)
+ * - Resolves relative to `assetParentPath` (defaults to `process.cwd()`)
+ * - Returns a branded `AbsolutePath` type
+ *
+ * **Note**: The commented-out validation that checks if the resolved path
+ * is within `assetParentPath` is disabled. This could be a security concern
+ * if used with user-provided paths.
+ *
+ * @param pathToFile - Path to convert (relative or absolute)
+ * @param assetParentPath - Base path for resolution (default: `process.cwd()`)
+ * @returns Absolute path as branded type
+ * @throws Error if path is not provided or is empty
+ */
+export function convertToFullPath(pathToFile, assetParentPath = process.cwd()) {
+    if (!pathToFile)
+        throw new Error('Path not provided');
+    if (pathToFile === '')
+        throw new Error('Empty path not allowed');
+    while (pathToFile.startsWith('/'))
+        pathToFile = pathToFile.substring(1);
+    const absolutePath = path.resolve(assetParentPath, pathToFile);
+    // if (!absolutePath.startsWith(assetParentPath))
+    // 	throw new Error(`Found path: '${absolutePath}' which is out of the scope of the assert directory: '${assetParentPath}'`);
+    return absolutePath;
+}

package/types.d.ts

@@ -0,0 +1,17 @@
+import { BaseCommando } from './core/BaseCommando.js';
+/**
+ * Log output types for shell commands.
+ *
+ * - `'out'`: Standard output (stdout)
+ * - `'err'`: Standard error (stderr)
+ */
+export type LogTypes = 'out' | 'err';
+/**
+ * Function type for command blocks that operate on a Commando instance.
+ *
+ * Used for composing command sequences where a function receives
+ * a Commando instance and builds commands on it.
+ *
+ * @template Commando - Commando type (must extend BaseCommando)
+ */
+export type CliBlock<Commando extends BaseCommando> = (cli: Commando) => void;

package/cli-params/CLIParamsResolver.d.ts

@@ -1,27 +0,0 @@
-import { BaseCliParam, CliParams } from './types.js';
-export declare class CLIParamsResolver<T extends BaseCliParam<string, any>[], Output extends CliParams<T> = CliParams<T>> {
-    private params;
-    static create<T extends BaseCliParam<string, any>[]>(...params: T): CLIParamsResolver<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/cli-params/CLIParamsResolver.js

@@ -1,97 +0,0 @@
-import { asArray, exists, filterDuplicates, StaticLogger } from '@nu-art/ts-common';
-import { DefaultProcessorsMapper } from './consts.js';
-export class CLIParamsResolver {
-    params;
-    static create(...params) {
-        return new CLIParamsResolver(params);
-    }
-    constructor(params) {
-        this.params = this.translate(params);
-    }
-    /**
-     * Format current input params and return it structured by the app params type.
-     * @param inputParams current console input arguments
-     * @returns CliParamsObject
-     */
-    resolveParamValue(inputParams = process.argv.slice(2, process.argv.length)) {
-        const runtimeParams = inputParams.reduce((output, inputParam) => {
-            let [key, value] = inputParam.split('=');
-            const cliParamToResolve = this.findMatchingParamToResolve(key);
-            if (!cliParamToResolve)
-                return output;
-            if (value && value.startsWith('"') && value.endsWith('"')) {
-                value = value.slice(1, -1);
-                value = value.replace(/\\"/g, '"');
-            }
-            const finalValue = cliParamToResolve.process(value, cliParamToResolve.defaultValue);
-            // validate options if exits
-            if (cliParamToResolve.options && !cliParamToResolve.options.includes(finalValue))
-                throw new Error(`value not supported for param: ${cliParamToResolve.name}, supported values: ${cliParamToResolve.options.join(', ')}`);
-            const keyName = cliParamToResolve.keyName;
-            if (exists(cliParamToResolve.dependencies))
-                cliParamToResolve.dependencies?.forEach(dependency => {
-                    // If dependency value is a function, call it with the current param's processed value
-                    const dependencyValue = typeof dependency.value === 'function'
-                        ? dependency.value(finalValue)
-                        : dependency.value;
-                    output[dependency.param.keyName] = dependencyValue;
-                });
-            if (cliParamToResolve.isArray) {
-                let currentValues = output[keyName];
-                currentValues = filterDuplicates([...(currentValues ?? []), ...asArray(finalValue)]);
-                output[keyName] = currentValues;
-                return output;
-            }
-            //if already exists and the value ain't an array warn that the value will be overridden
-            if (output[keyName])
-                StaticLogger.logWarning(`this param does not accept multiple values, overriding prev value: ${output[keyName]}`);
-            //Apply a single value to the object
-            output[keyName] = finalValue;
-            return output;
-        }, {});
-        this.params.filter(param => exists(param.initialValue) && !exists(runtimeParams[param.keyName])).forEach(param => {
-            runtimeParams[param.keyName] = param.initialValue;
-        });
-        return runtimeParams;
-    }
-    /**
-     * 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
-     */
-    findMatchingParamToResolve(inputParam) {
-        let matchingParam;
-        this.params.forEach((param) => {
-            param.keys.forEach((key) => {
-                if (inputParam === key)
-                    matchingParam = param;
-                if (inputParam.startsWith(`${key}=`))
-                    matchingParam = param;
-            });
-        });
-        return matchingParam;
-    }
-    /**
-     * 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
-     */
-    translate(params) {
-        return params.map(param => {
-            //If name is not defined apply key name as the param name
-            if (!param.name)
-                param.name = param.keyName;
-            //If no processor is passed apply default by type
-            if (!param.process) {
-                param.process = DefaultProcessorsMapper[param.type.split('[')[0].trim()];
-            }
-            //Determine if value is array by the param type TODO: improve this chunk of code, this is not strict enough
-            if (!exists(param.isArray) && param.type.includes('[]'))
-                param.isArray = true;
-            return param;
-        });
-    }
-}

package/cli-params/consts.d.ts

@@ -1,6 +0,0 @@
-import { TypedMap } from '@nu-art/ts-common';
-import { CliParam } from './types.js';
-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 declare const DefaultProcessorsMapper: TypedMap<CliParam<any, any>['process']>;

package/cli-params/consts.js

@@ -1,27 +0,0 @@
-import { exists } from '@nu-art/ts-common';
-export const DefaultProcessor_Boolean = (input, defaultValue) => {
-    return true;
-};
-export const DefaultProcessor_String = (input, defaultValue) => {
-    if (!input || !input.length) {
-        if (!exists(defaultValue))
-            throw new Error('expected string value');
-        return defaultValue;
-    }
-    return input;
-};
-export const DefaultProcessor_Number = (input, defaultValue) => {
-    if (!input) {
-        if (!exists(defaultValue))
-            throw new Error('expected number value');
-        return defaultValue;
-    }
-    if (isNaN(Number(input)))
-        throw new Error('expected number value');
-    return Number(input);
-};
-export const DefaultProcessorsMapper = {
-    string: DefaultProcessor_String,
-    boolean: DefaultProcessor_Boolean,
-    number: DefaultProcessor_Number,
-};

package/cli-params/types.d.ts

@@ -1,28 +0,0 @@
-import { Primitive, TypeOfTypeAsString } from '@nu-art/ts-common';
-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 | ((currentValue: any) => T);
-};
-export type BaseCliParam<K extends string, V extends Primitive | Primitive[]> = {
-    keys: string[];
-    keyName: K;
-    type: TypeOfTypeAsString<V>;
-    description: string;
-    name?: string;
-    options?: string[];
-    initialValue?: V;
-    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;
-};

package/shell/core/CliError.d.ts

@@ -1,14 +0,0 @@
-import { CustomException } from '@nu-art/ts-common';
-import { ExecException } from 'child_process';
-export declare class CliError extends CustomException {
-    stdout: string;
-    stderr: string;
-    cause: ExecException;
-    constructor(message: string, stdout: string, stderr: string, cause: ExecException);
-}
-export declare class CommandoException extends CustomException {
-    stdout: string;
-    stderr: string;
-    exitCode: number;
-    constructor(message: string, stdout: string, stderr: string, exitCode: number);
-}

package/shell/core/CliError.js

@@ -1,23 +0,0 @@
-import { CustomException } from '@nu-art/ts-common';
-export class CliError extends CustomException {
-    stdout;
-    stderr;
-    cause;
-    constructor(message, stdout, stderr, cause) {
-        super(CliError, message, cause);
-        this.stdout = stdout;
-        this.stderr = stderr;
-        this.cause = cause;
-    }
-}
-export class CommandoException extends CustomException {
-    stdout;
-    stderr;
-    exitCode;
-    constructor(message, stdout, stderr, exitCode) {
-        super(CliError, message);
-        this.stdout = stdout;
-        this.stderr = stderr;
-        this.exitCode = exitCode;
-    }
-}

package/shell/core/CommandoPool.d.ts

@@ -1,9 +0,0 @@
-import { Constructor } from '@nu-art/ts-common';
-import { CommandoInteractive } from '../interactive/CommandoInteractive.js';
-import { BaseCommando } from './BaseCommando.js';
-import { Commando_Basic } from '../plugins/basic.js';
-import { MergeTypes } from './class-merger.js';
-export declare const CommandoPool: {
-    allocateCommando: <T extends Constructor<any>[]>(uid: string, ...plugins: T) => MergeTypes<[...T]> & CommandoInteractive & BaseCommando & Commando_Basic;
-    killAll: () => Promise<void>;
-};

package/shell/core/CommandoPool.js

@@ -1,14 +0,0 @@
-import { CommandoInteractive } from '../interactive/CommandoInteractive.js';
-import { Commando_Basic } from '../plugins/basic.js';
-const commandoPool = [];
-export const CommandoPool = {
-    allocateCommando: (uid, ...plugins) => {
-        const commando = CommandoInteractive.create(...plugins, Commando_Basic);
-        commando.setUID(uid);
-        commandoPool.push(commando);
-        return commando;
-    },
-    killAll: async () => {
-        await Promise.all(commandoPool.map(c => c.kill()));
-    }
-};

package/shell/core/class-merger.d.ts

@@ -1,20 +0,0 @@
-import { Constructor } from '@nu-art/ts-common';
-/**
- * Type utility to recursively merge the types of constructors in an array.
- * @template T - An array of constructors.
- */
-export type MergeTypes<T extends Constructor<any>[]> = T extends [a: Constructor<infer A>, ...rest: infer R] ? R extends Constructor<any>[] ? A & MergeTypes<R> : {} : {};
-/**
- * Function to merge multiple classes into a single class.
- * @template T - An array of constructors.
- * @param {...T} plugins - The constructors to merge.
- * @returns {Constructor<MergeTypes<T>>} - A new constructor that merges all the provided constructors.
- */
-export declare function MergeClass<T extends Constructor<any>[]>(...plugins: T): Constructor<MergeTypes<T>>;
-/**
- * Function to create an instance of a class that merges multiple classes.
- * @template T - An array of constructors.
- * @param {...T} plugins - The constructors to merge.
- * @returns {MergeTypes<T>} - An instance of the merged class.
- */
-export declare function CreateMergedInstance<T extends Constructor<any>[]>(...plugins: T): MergeTypes<T>;

package/shell/core/class-merger.js

@@ -1,35 +0,0 @@
-/**
- * Function to merge multiple classes into a single class.
- * @template T - An array of constructors.
- * @param {...T} plugins - The constructors to merge.
- * @returns {Constructor<MergeTypes<T>>} - A new constructor that merges all the provided constructors.
- */
-export function MergeClass(...plugins) {
-    class SuperClass {
-        /**
-         * Constructs an instance of SuperClass, merging properties from all plugins.
-         * @param {...any[]} args - The arguments to pass to the constructors.
-         */
-        constructor(...args) {
-            plugins.forEach(plugin => {
-                Object.getOwnPropertyNames(plugin.prototype).forEach(name => {
-                    const prop = Object.getOwnPropertyDescriptor(plugin.prototype, name);
-                    if (prop) {
-                        Object.defineProperty(this, name, prop);
-                    }
-                });
-            });
-        }
-    }
-    return SuperClass;
-}
-/**
- * Function to create an instance of a class that merges multiple classes.
- * @template T - An array of constructors.
- * @param {...T} plugins - The constructors to merge.
- * @returns {MergeTypes<T>} - An instance of the merged class.
- */
-export function CreateMergedInstance(...plugins) {
-    const SuperClass = MergeClass(...plugins);
-    return new SuperClass();
-}

package/shell/index.d.ts

@@ -1,2 +0,0 @@
-export * from './interactive/CommandoInteractive.js';
-export * from './simple/Commando.js';

package/shell/index.js

@@ -1,2 +0,0 @@
-export * from './interactive/CommandoInteractive.js';
-export * from './simple/Commando.js';