@push.rocks/smartshell 3.0.3

package/dist_ts/00_commitinfo_data.d.ts

@@ -0,0 +1,8 @@
+/**
+ * autocreated commitinfo by @pushrocks/commitinfo
+ */
+export declare const commitinfo: {
+    name: string;
+    version: string;
+    description: string;
+};

package/dist_ts/00_commitinfo_data.js

@@ -0,0 +1,9 @@
+/**
+ * autocreated commitinfo by @pushrocks/commitinfo
+ */
+export const commitinfo = {
+    name: '@pushrocks/smartshell',
+    version: '3.0.3',
+    description: 'shell actions designed as promises'
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSx1QkFBdUI7SUFDN0IsT0FBTyxFQUFFLE9BQU87SUFDaEIsV0FBVyxFQUFFLG9DQUFvQztDQUNsRCxDQUFBIn0=

package/dist_ts/index.d.ts

@@ -0,0 +1,2 @@
+export * from './smartshell.classes.smartshell.js';
+export { which } from './smartshell.plugins.js';

package/dist_ts/index.js

@@ -0,0 +1,3 @@
+export * from './smartshell.classes.smartshell.js';
+export { which } from './smartshell.plugins.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLG9DQUFvQyxDQUFDO0FBQ25ELE9BQU8sRUFBRSxLQUFLLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQyJ9

package/dist_ts/smartshell.classes.shellenv.d.ts

@@ -0,0 +1,29 @@
+export type TExecutor = 'sh' | 'bash';
+export interface IShellEnvContructorOptions {
+    executor: TExecutor;
+    sourceFilePaths?: string[];
+    pathDirectories?: string[];
+}
+export declare class ShellEnv {
+    executor: TExecutor;
+    sourceFileArray: string[];
+    pathDirArray: string[];
+    /**
+     * constructor for the shellenv
+     */
+    constructor(optionsArg: IShellEnvContructorOptions);
+    /**
+     * imports path into the shell from env if available and returns it with
+     */
+    private _setPath;
+    /**
+     * add files that are going to be sourced when running a command
+     * @param sourceFilePathsArray
+     */
+    addSourceFiles(sourceFilePathsArray: string[]): void;
+    /**
+     * cleans the source files array
+     */
+    cleanSourceFiles(): void;
+    createEnvExecString(commandArg: string): string;
+}

package/dist_ts/smartshell.classes.shellenv.js

@@ -0,0 +1,82 @@
+export class ShellEnv {
+    /**
+     * constructor for the shellenv
+     */
+    constructor(optionsArg) {
+        this.sourceFileArray = [];
+        this.pathDirArray = [];
+        this.executor = optionsArg.executor;
+        // add sourcefiles
+        if (optionsArg.sourceFilePaths) {
+            this.sourceFileArray = this.sourceFileArray.concat(optionsArg.sourceFilePaths);
+        }
+        // add pathDirectories
+        if (optionsArg.pathDirectories) {
+            this.pathDirArray = this.pathDirArray.concat(optionsArg.pathDirectories);
+        }
+    }
+    /**
+     * imports path into the shell from env if available and returns it with
+     */
+    _setPath(commandStringArg) {
+        let commandResult = commandStringArg;
+        let commandPaths = [];
+        commandPaths = commandPaths.concat(process.env.PATH.split(':'));
+        if (process.env.SMARTSHELL_PATH) {
+            commandPaths = commandPaths.concat(process.env.SMARTSHELL_PATH.split(':'));
+        }
+        // lets filter for unwanted paths
+        // Windows WSL
+        commandPaths = commandPaths.filter((commandPathArg) => {
+            const filterResult = !commandPathArg.startsWith('/mnt/c/') &&
+                !commandPathArg.startsWith('Files/1E') &&
+                !commandPathArg.includes(' ');
+            if (!filterResult) {
+                // console.log(`${commandPathArg} will be filtered!`);
+            }
+            return filterResult;
+        });
+        commandResult = `PATH=${commandPaths.join(':')} && ${commandStringArg}`;
+        return commandResult;
+    }
+    /**
+     * add files that are going to be sourced when running a command
+     * @param sourceFilePathsArray
+     */
+    addSourceFiles(sourceFilePathsArray) {
+        for (let sourceFilePath of sourceFilePathsArray) {
+            this.sourceFileArray.push(sourceFilePath);
+        }
+    }
+    /**
+     * cleans the source files array
+     */
+    cleanSourceFiles() {
+        this.sourceFileArray = [];
+    }
+    createEnvExecString(commandArg) {
+        let commandResult = '';
+        let sourceString = '';
+        // deal with sourcestring
+        for (const sourceFilePath of this.sourceFileArray) {
+            sourceString = sourceString + `source ${sourceFilePath} && `;
+        }
+        // deal with available path
+        let pathString = 'PATH=$PATH';
+        for (const pathDir of this.pathDirArray) {
+            pathString += `:${pathDir}`;
+        }
+        pathString += ` && `;
+        switch (this.executor) {
+            case 'bash':
+                commandResult = `bash -c '${pathString}${sourceString}${commandArg}'`;
+                break;
+            case 'sh':
+                commandResult = `${pathString}${sourceString}${commandArg}`;
+                break;
+        }
+        commandResult = this._setPath(commandResult);
+        return commandResult;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/smartshell.classes.shelllog.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="node" resolution-mode="require"/>
+/**
+ * a log handler for spawned logs
+ * making sure the process doesn't run out of memory
+ */
+export declare class ShellLog {
+    logStore: Buffer;
+    /**
+     * log data to console
+     * @param dataArg
+     */
+    writeToConsole(dataArg: string | Buffer): void;
+    /**
+     * add data to Buffer for later consumption
+     * @param dataArg
+     */
+    addToBuffer(dataArg: string | Buffer): void;
+    logAndAdd(dataArg: string | Buffer): void;
+}

package/dist_ts/smartshell.classes.shelllog.js

@@ -0,0 +1,37 @@
+import * as plugins from './smartshell.plugins.js';
+/**
+ * a log handler for spawned logs
+ * making sure the process doesn't run out of memory
+ */
+export class ShellLog {
+    constructor() {
+        this.logStore = Buffer.from('');
+    }
+    /**
+     * log data to console
+     * @param dataArg
+     */
+    writeToConsole(dataArg) {
+        // make sure we have the data as string
+        process.stdout.write(dataArg);
+    }
+    /**
+     * add data to Buffer for later consumption
+     * @param dataArg
+     */
+    addToBuffer(dataArg) {
+        // make sure we have the data as Buffer
+        const dataBuffer = (() => {
+            if (!Buffer.isBuffer(dataArg)) {
+                return Buffer.from(dataArg);
+            }
+            return dataArg;
+        })();
+        this.logStore = Buffer.concat([this.logStore, dataBuffer]);
+    }
+    logAndAdd(dataArg) {
+        this.writeToConsole(dataArg);
+        this.addToBuffer(dataArg);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRzaGVsbC5jbGFzc2VzLnNoZWxsbG9nLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvc21hcnRzaGVsbC5jbGFzc2VzLnNoZWxsbG9nLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxPQUFPLE1BQU0seUJBQXlCLENBQUM7QUFFbkQ7OztHQUdHO0FBQ0gsTUFBTSxPQUFPLFFBQVE7SUFBckI7UUFDUyxhQUFRLEdBQUcsTUFBTSxDQUFDLElBQUksQ0FBQyxFQUFFLENBQUMsQ0FBQztJQThCcEMsQ0FBQztJQTVCQzs7O09BR0c7SUFDSSxjQUFjLENBQUMsT0FBd0I7UUFDNUMsdUNBQXVDO1FBQ3ZDLE9BQU8sQ0FBQyxNQUFNLENBQUMsS0FBSyxDQUFDLE9BQU8sQ0FBQyxDQUFDO0lBQ2hDLENBQUM7SUFFRDs7O09BR0c7SUFDSSxXQUFXLENBQUMsT0FBd0I7UUFDekMsdUNBQXVDO1FBQ3ZDLE1BQU0sVUFBVSxHQUFXLENBQUMsR0FBRyxFQUFFO1lBQy9CLElBQUksQ0FBQyxNQUFNLENBQUMsUUFBUSxDQUFDLE9BQU8sQ0FBQyxFQUFFO2dCQUM3QixPQUFPLE1BQU0sQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLENBQUM7YUFDN0I7WUFDRCxPQUFPLE9BQU8sQ0FBQztRQUNqQixDQUFDLENBQUMsRUFBRSxDQUFDO1FBQ0wsSUFBSSxDQUFDLFFBQVEsR0FBRyxNQUFNLENBQUMsTUFBTSxDQUFDLENBQUMsSUFBSSxDQUFDLFFBQVEsRUFBRSxVQUFVLENBQUMsQ0FBQyxDQUFDO0lBQzdELENBQUM7SUFFTSxTQUFTLENBQUMsT0FBd0I7UUFDdkMsSUFBSSxDQUFDLGNBQWMsQ0FBQyxPQUFPLENBQUMsQ0FBQztRQUM3QixJQUFJLENBQUMsV0FBVyxDQUFDLE9BQU8sQ0FBQyxDQUFDO0lBQzVCLENBQUM7Q0FDRiJ9

package/dist_ts/smartshell.classes.smartshell.d.ts

@@ -0,0 +1,33 @@
+/// <reference types="node" resolution-mode="require"/>
+import * as plugins from './smartshell.plugins.js';
+import { ShellEnv } from './smartshell.classes.shellenv.js';
+import type { IShellEnvContructorOptions } from './smartshell.classes.shellenv.js';
+import * as cp from 'child_process';
+export interface IExecResult {
+    exitCode: number;
+    stdout: string;
+}
+export interface IExecResultStreaming {
+    childProcess: cp.ChildProcess;
+    finalPromise: Promise<IExecResult>;
+    kill: () => void;
+    terminate: () => void;
+}
+export declare class Smartshell {
+    shellEnv: ShellEnv;
+    smartexit: plugins.smartexit.SmartExit;
+    constructor(optionsArg: IShellEnvContructorOptions);
+    /**
+     * executes a given command async
+     */
+    private _exec;
+    exec(commandString: string): Promise<IExecResult>;
+    execSilent(commandString: string): Promise<IExecResult>;
+    execStrict(commandString: string): Promise<IExecResult>;
+    execStrictSilent(commandString: string): Promise<IExecResult>;
+    execStreaming(commandString: string, silent?: boolean): Promise<IExecResultStreaming>;
+    execStreamingSilent(commandString: string): Promise<IExecResultStreaming>;
+    execInteractive(commandString: string): Promise<void>;
+    execAndWaitForLine(commandString: string, regexArg: RegExp, silentArg?: boolean): Promise<unknown>;
+    execAndWaitForLineSilent(commandString: string, regexArg: RegExp): Promise<unknown>;
+}

package/dist_ts/smartshell.classes.smartshell.js

@@ -0,0 +1,127 @@
+import * as plugins from './smartshell.plugins.js';
+import { ShellEnv } from './smartshell.classes.shellenv.js';
+import { ShellLog } from './smartshell.classes.shelllog.js';
+import * as cp from 'child_process';
+export class Smartshell {
+    constructor(optionsArg) {
+        this.smartexit = new plugins.smartexit.SmartExit();
+        this.shellEnv = new ShellEnv(optionsArg);
+    }
+    /**
+     * executes a given command async
+     */
+    async _exec(options) {
+        if (options.interactive) {
+            if (process.env.CI) {
+                return;
+            }
+            const done = plugins.smartpromise.defer();
+            // Notice that stdio is set to 'inherit'
+            const shell = cp.spawn(options.commandString, {
+                stdio: 'inherit',
+                shell: true,
+                detached: true
+            });
+            this.smartexit.addProcess(shell);
+            shell.on('close', (code) => {
+                console.log(`interactive shell terminated with code ${code}`);
+                this.smartexit.removeProcess(shell);
+                done.resolve();
+            });
+            await done.promise;
+            return;
+        }
+        const done = plugins.smartpromise.defer();
+        const childProcessEnded = plugins.smartpromise.defer();
+        let commandToExecute = options.commandString;
+        commandToExecute = this.shellEnv.createEnvExecString(options.commandString);
+        const spawnlogInstance = new ShellLog();
+        const execChildProcess = cp.spawn(commandToExecute, [], {
+            shell: true,
+            cwd: process.cwd(),
+            env: process.env,
+            detached: false,
+        });
+        this.smartexit.addProcess(execChildProcess);
+        execChildProcess.stdout.on('data', (data) => {
+            if (!options.silent) {
+                spawnlogInstance.writeToConsole(data);
+            }
+            spawnlogInstance.addToBuffer(data);
+        });
+        execChildProcess.stderr.on('data', (data) => {
+            if (!options.silent) {
+                spawnlogInstance.writeToConsole(data);
+            }
+            spawnlogInstance.addToBuffer(data);
+        });
+        execChildProcess.on('exit', (code, signal) => {
+            this.smartexit.removeProcess(execChildProcess);
+            if (options.strict && code === 1) {
+                done.reject();
+            }
+            const execResult = {
+                exitCode: code,
+                stdout: spawnlogInstance.logStore.toString(),
+            };
+            if (!options.streaming) {
+                done.resolve(execResult);
+            }
+            childProcessEnded.resolve(execResult);
+        });
+        if (options.streaming) {
+            done.resolve({
+                childProcess: execChildProcess,
+                finalPromise: childProcessEnded.promise,
+                kill: () => {
+                    console.log(`running tree kill with SIGKILL on process ${execChildProcess.pid}`);
+                    plugins.treeKill(execChildProcess.pid, 'SIGKILL');
+                },
+                terminate: () => {
+                    console.log(`running tree kill with SIGTERM on process ${execChildProcess.pid}`);
+                    plugins.treeKill(execChildProcess.pid, 'SIGTERM');
+                },
+            });
+        }
+        return await done.promise;
+    }
+    async exec(commandString) {
+        return (await this._exec({ commandString }));
+    }
+    async execSilent(commandString) {
+        return (await this._exec({ commandString, silent: true }));
+    }
+    async execStrict(commandString) {
+        return (await this._exec({ commandString, strict: true }));
+    }
+    async execStrictSilent(commandString) {
+        return (await this._exec({ commandString, silent: true, strict: true }));
+    }
+    async execStreaming(commandString, silent = false) {
+        return (await this._exec({ commandString, silent, streaming: true }));
+    }
+    async execStreamingSilent(commandString) {
+        return (await this._exec({
+            commandString,
+            silent: true,
+            streaming: true,
+        }));
+    }
+    async execInteractive(commandString) {
+        await this._exec({ commandString, interactive: true });
+    }
+    async execAndWaitForLine(commandString, regexArg, silentArg = false) {
+        let done = plugins.smartpromise.defer();
+        let execStreamingResult = await this.execStreaming(commandString, silentArg);
+        execStreamingResult.childProcess.stdout.on('data', (stdOutChunk) => {
+            if (regexArg.test(stdOutChunk)) {
+                done.resolve();
+            }
+        });
+        return done.promise;
+    }
+    async execAndWaitForLineSilent(commandString, regexArg) {
+        return this.execAndWaitForLine(commandString, regexArg, true);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/smartshell.plugins.d.ts

@@ -0,0 +1,7 @@
+import * as smartdelay from '@pushrocks/smartdelay';
+import * as smartexit from '@pushrocks/smartexit';
+import * as smartpromise from '@pushrocks/smartpromise';
+import which from 'which';
+export { smartdelay, smartexit, smartpromise, which };
+import treeKill from 'tree-kill';
+export { treeKill };

package/dist_ts/smartshell.plugins.js

@@ -0,0 +1,9 @@
+import * as smartdelay from '@pushrocks/smartdelay';
+import * as smartexit from '@pushrocks/smartexit';
+import * as smartpromise from '@pushrocks/smartpromise';
+import which from 'which';
+export { smartdelay, smartexit, smartpromise, which };
+// third party
+import treeKill from 'tree-kill';
+export { treeKill };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRzaGVsbC5wbHVnaW5zLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvc21hcnRzaGVsbC5wbHVnaW5zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxVQUFVLE1BQU0sdUJBQXVCLENBQUM7QUFDcEQsT0FBTyxLQUFLLFNBQVMsTUFBTSxzQkFBc0IsQ0FBQztBQUNsRCxPQUFPLEtBQUssWUFBWSxNQUFNLHlCQUF5QixDQUFDO0FBQ3hELE9BQU8sS0FBSyxNQUFNLE9BQU8sQ0FBQztBQUUxQixPQUFPLEVBQUUsVUFBVSxFQUFFLFNBQVMsRUFBRSxZQUFZLEVBQUUsS0FBSyxFQUFFLENBQUM7QUFFdEQsY0FBYztBQUNkLE9BQU8sUUFBUSxNQUFNLFdBQVcsQ0FBQztBQUVqQyxPQUFPLEVBQUUsUUFBUSxFQUFFLENBQUMifQ==

package/npmextra.json

@@ -0,0 +1,18 @@
+{
+  "npmci": {
+    "npmGlobalTools": [],
+    "npmAccessLevel": "public",
+    "npmRegistryUrl": "registry.npmjs.org"
+  },
+  "gitzone": {
+    "projectType": "npm",
+    "module": {
+      "githost": "gitlab.com",
+      "gitscope": "pushrocks",
+      "gitrepo": "smartshell",
+      "description": "shell actions designed as promises",
+      "npmPackagename": "@pushrocks/smartshell",
+      "license": "MIT"
+    }
+  }
+}

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@push.rocks/smartshell",
+  "private": false,
+  "version": "3.0.3",
+  "description": "shell actions designed as promises",
+  "main": "dist_ts/index.js",
+  "typings": "dist_ts/index.d.ts",
+  "type": "module",
+  "scripts": {
+    "test": "(tstest test/)",
+    "build": "(tsbuild --web)",
+    "buildDocs": "tsdoc"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@gitlab.com/pushrocks/smartshell.git"
+  },
+  "keywords": [
+    "shell",
+    "promise"
+  ],
+  "author": "Lossless GmbH",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://gitlab.com/pushrocks/smartshell/issues"
+  },
+  "homepage": "https://gitlab.com/pushrocks/smartshell#README",
+  "devDependencies": {
+    "@gitzone/tsbuild": "^2.1.66",
+    "@gitzone/tsrun": "^1.2.42",
+    "@gitzone/tstest": "^1.0.74",
+    "@pushrocks/tapbundle": "^5.0.8",
+    "@types/node": "^20.3.1"
+  },
+  "dependencies": {
+    "@pushrocks/smartdelay": "^3.0.1",
+    "@pushrocks/smartexit": "^1.0.20",
+    "@pushrocks/smartpromise": "^4.0.2",
+    "@types/which": "^3.0.0",
+    "tree-kill": "^1.2.2",
+    "which": "^3.0.1"
+  },
+  "files": [
+    "ts/**/*",
+    "ts_web/**/*",
+    "dist/**/*",
+    "dist_*/**/*",
+    "dist_ts/**/*",
+    "dist_ts_web/**/*",
+    "assets/**/*",
+    "cli.js",
+    "npmextra.json",
+    "readme.md"
+  ],
+  "browserslist": [
+    "last 1 chrome versions"
+  ]
+}

package/readme.md

@@ -0,0 +1,37 @@
+# @pushrocks/smartshell
+shell actions designed as promises
+
+## Availabililty and Links
+* [npmjs.org (npm package)](https://www.npmjs.com/package/@pushrocks/smartshell)
+* [gitlab.com (source)](https://gitlab.com/pushrocks/smartshell)
+* [github.com (source mirror)](https://github.com/pushrocks/smartshell)
+* [docs (typedoc)](https://pushrocks.gitlab.io/smartshell/)
+
+## Status for master
+
+Status Category | Status Badge
+-- | --
+GitLab Pipelines | [![pipeline status](https://gitlab.com/pushrocks/smartshell/badges/master/pipeline.svg)](https://lossless.cloud)
+GitLab Pipline Test Coverage | [![coverage report](https://gitlab.com/pushrocks/smartshell/badges/master/coverage.svg)](https://lossless.cloud)
+npm | [![npm downloads per month](https://badgen.net/npm/dy/@pushrocks/smartshell)](https://lossless.cloud)
+Snyk | [![Known Vulnerabilities](https://badgen.net/snyk/pushrocks/smartshell)](https://lossless.cloud)
+TypeScript Support | [![TypeScript](https://badgen.net/badge/TypeScript/>=%203.x/blue?icon=typescript)](https://lossless.cloud)
+node Support | [![node](https://img.shields.io/badge/node->=%2010.x.x-blue.svg)](https://nodejs.org/dist/latest-v10.x/docs/api/)
+Code Style | [![Code Style](https://badgen.net/badge/style/prettier/purple)](https://lossless.cloud)
+PackagePhobia (total standalone install weight) | [![PackagePhobia](https://badgen.net/packagephobia/install/@pushrocks/smartshell)](https://lossless.cloud)
+PackagePhobia (package size on registry) | [![PackagePhobia](https://badgen.net/packagephobia/publish/@pushrocks/smartshell)](https://lossless.cloud)
+BundlePhobia (total size when bundled) | [![BundlePhobia](https://badgen.net/bundlephobia/minzip/@pushrocks/smartshell)](https://lossless.cloud)
+
+## Usage
+
+Use TypeScript for best in class instellisense.
+
+## Contribution
+
+We are always happy for code contributions. If you are not the code contributing type that is ok. Still, maintaining Open Source repositories takes considerable time and thought. If you like the quality of what we do and our modules are useful to you we would appreciate a little monthly contribution: You can [contribute one time](https://lossless.link/contribute-onetime) or [contribute monthly](https://lossless.link/contribute). :)
+
+For further information read the linked docs at the top of this readme.
+
+## Legal
+> MIT licensed | **©** [Task Venture Capital GmbH](https://task.vc)
+| By using this npm module you agree to our [privacy policy](https://lossless.gmbH/privacy)

package/ts/00_commitinfo_data.ts

@@ -0,0 +1,8 @@
+/**
+ * autocreated commitinfo by @pushrocks/commitinfo
+ */
+export const commitinfo = {
+  name: '@pushrocks/smartshell',
+  version: '3.0.3',
+  description: 'shell actions designed as promises'
+}

package/ts/index.ts

@@ -0,0 +1,2 @@
+export * from './smartshell.classes.smartshell.js';
+export { which } from './smartshell.plugins.js';

package/ts/smartshell.classes.shellenv.ts

@@ -0,0 +1,103 @@
+export type TExecutor = 'sh' | 'bash';
+
+export interface IShellEnvContructorOptions {
+  executor: TExecutor;
+  sourceFilePaths?: string[];
+  pathDirectories?: string[];
+}
+
+export class ShellEnv {
+  executor: TExecutor;
+  sourceFileArray: string[] = [];
+  pathDirArray: string[] = [];
+
+  /**
+   * constructor for the shellenv
+   */
+  constructor(optionsArg: IShellEnvContructorOptions) {
+    this.executor = optionsArg.executor;
+
+    // add sourcefiles
+    if (optionsArg.sourceFilePaths) {
+      this.sourceFileArray = this.sourceFileArray.concat(optionsArg.sourceFilePaths);
+    }
+
+    // add pathDirectories
+    if (optionsArg.pathDirectories) {
+      this.pathDirArray = this.pathDirArray.concat(optionsArg.pathDirectories);
+    }
+  }
+
+  /**
+   * imports path into the shell from env if available and returns it with
+   */
+  private _setPath(commandStringArg: string): string {
+    let commandResult = commandStringArg;
+    let commandPaths: string[] = [];
+    commandPaths = commandPaths.concat(process.env.PATH.split(':'));
+    if (process.env.SMARTSHELL_PATH) {
+      commandPaths = commandPaths.concat(process.env.SMARTSHELL_PATH.split(':'));
+    }
+
+    // lets filter for unwanted paths
+    // Windows WSL
+    commandPaths = commandPaths.filter((commandPathArg) => {
+      const filterResult =
+        !commandPathArg.startsWith('/mnt/c/') &&
+        !commandPathArg.startsWith('Files/1E') &&
+        !commandPathArg.includes(' ');
+      if (!filterResult) {
+        // console.log(`${commandPathArg} will be filtered!`);
+      }
+      return filterResult;
+    });
+
+    commandResult = `PATH=${commandPaths.join(':')} && ${commandStringArg}`;
+    return commandResult;
+  }
+
+  /**
+   * add files that are going to be sourced when running a command
+   * @param sourceFilePathsArray
+   */
+  addSourceFiles(sourceFilePathsArray: string[]) {
+    for (let sourceFilePath of sourceFilePathsArray) {
+      this.sourceFileArray.push(sourceFilePath);
+    }
+  }
+
+  /**
+   * cleans the source files array
+   */
+  cleanSourceFiles() {
+    this.sourceFileArray = [];
+  }
+
+  public createEnvExecString(commandArg: string): string {
+    let commandResult = '';
+    let sourceString = '';
+
+    // deal with sourcestring
+    for (const sourceFilePath of this.sourceFileArray) {
+      sourceString = sourceString + `source ${sourceFilePath} && `;
+    }
+
+    // deal with available path
+    let pathString = 'PATH=$PATH';
+    for (const pathDir of this.pathDirArray) {
+      pathString += `:${pathDir}`;
+    }
+    pathString += ` && `;
+
+    switch (this.executor) {
+      case 'bash':
+        commandResult = `bash -c '${pathString}${sourceString}${commandArg}'`;
+        break;
+      case 'sh':
+        commandResult = `${pathString}${sourceString}${commandArg}`;
+        break;
+    }
+    commandResult = this._setPath(commandResult);
+    return commandResult;
+  }
+}

package/ts/smartshell.classes.shelllog.ts

@@ -0,0 +1,38 @@
+import * as plugins from './smartshell.plugins.js';
+
+/**
+ * a log handler for spawned logs
+ * making sure the process doesn't run out of memory
+ */
+export class ShellLog {
+  public logStore = Buffer.from('');
+
+  /**
+   * log data to console
+   * @param dataArg
+   */
+  public writeToConsole(dataArg: string | Buffer): void {
+    // make sure we have the data as string
+    process.stdout.write(dataArg);
+  }
+
+  /**
+   * add data to Buffer for later consumption
+   * @param dataArg
+   */
+  public addToBuffer(dataArg: string | Buffer): void {
+    // make sure we have the data as Buffer
+    const dataBuffer: Buffer = (() => {
+      if (!Buffer.isBuffer(dataArg)) {
+        return Buffer.from(dataArg);
+      }
+      return dataArg;
+    })();
+    this.logStore = Buffer.concat([this.logStore, dataBuffer]);
+  }
+
+  public logAndAdd(dataArg: string | Buffer): void {
+    this.writeToConsole(dataArg);
+    this.addToBuffer(dataArg);
+  }
+}

package/ts/smartshell.classes.smartshell.ts

@@ -0,0 +1,184 @@
+import * as plugins from './smartshell.plugins.js';
+import { ShellEnv } from './smartshell.classes.shellenv.js';
+import type { IShellEnvContructorOptions, TExecutor } from './smartshell.classes.shellenv.js';
+import { ShellLog } from './smartshell.classes.shelllog.js';
+
+import * as cp from 'child_process';
+
+// -- interfaces --
+export interface IExecResult {
+  exitCode: number;
+  stdout: string;
+}
+
+export interface IExecResultStreaming {
+  childProcess: cp.ChildProcess;
+  finalPromise: Promise<IExecResult>;
+  kill: () => void;
+  terminate: () => void;
+}
+
+export class Smartshell {
+  public shellEnv: ShellEnv;
+  public smartexit = new plugins.smartexit.SmartExit();
+
+  constructor(optionsArg: IShellEnvContructorOptions) {
+    this.shellEnv = new ShellEnv(optionsArg);
+  }
+
+  /**
+   * executes a given command async
+   */
+  private async _exec(options: {
+    commandString: string;
+    silent?: boolean;
+    strict?: boolean;
+    streaming?: boolean;
+    interactive?: boolean;
+  }): Promise<IExecResult | IExecResultStreaming | void> {
+    if (options.interactive) {
+      if (process.env.CI) {
+        return;
+      }
+
+      const done = plugins.smartpromise.defer();
+      
+      // Notice that stdio is set to 'inherit'
+      const shell = cp.spawn(options.commandString, {
+        stdio: 'inherit',
+        shell: true,
+        detached: true
+      });
+
+      this.smartexit.addProcess(shell);
+
+      shell.on('close', (code) => {
+        console.log(`interactive shell terminated with code ${code}`);
+        this.smartexit.removeProcess(shell);
+        done.resolve();
+      });
+
+      await done.promise;
+
+      return;
+    }
+
+    const done = plugins.smartpromise.defer<IExecResult | IExecResultStreaming>();
+    const childProcessEnded = plugins.smartpromise.defer<IExecResult>();
+
+    let commandToExecute = options.commandString;
+    commandToExecute = this.shellEnv.createEnvExecString(options.commandString);
+
+    const spawnlogInstance = new ShellLog();
+    const execChildProcess = cp.spawn(commandToExecute, [], {
+      shell: true,
+      cwd: process.cwd(),
+      env: process.env,
+      detached: false,
+    });
+
+    this.smartexit.addProcess(execChildProcess);
+
+    execChildProcess.stdout.on('data', (data) => {
+      if (!options.silent) {
+        spawnlogInstance.writeToConsole(data);
+      }
+      spawnlogInstance.addToBuffer(data);
+    });
+
+    execChildProcess.stderr.on('data', (data) => {
+      if (!options.silent) {
+        spawnlogInstance.writeToConsole(data);
+      }
+      spawnlogInstance.addToBuffer(data);
+    });
+
+    execChildProcess.on('exit', (code, signal) => {
+      this.smartexit.removeProcess(execChildProcess);
+      if (options.strict && code === 1) {
+        done.reject();
+      }
+
+      const execResult = {
+        exitCode: code,
+        stdout: spawnlogInstance.logStore.toString(),
+      };
+
+      if (!options.streaming) {
+        done.resolve(execResult);
+      }
+      childProcessEnded.resolve(execResult);
+    });
+
+    if (options.streaming) {
+      done.resolve({
+        childProcess: execChildProcess,
+        finalPromise: childProcessEnded.promise,
+        kill: () => {
+          console.log(`running tree kill with SIGKILL on process ${execChildProcess.pid}`);
+          plugins.treeKill(execChildProcess.pid, 'SIGKILL');
+        },
+        terminate: () => {
+          console.log(`running tree kill with SIGTERM on process ${execChildProcess.pid}`);
+          plugins.treeKill(execChildProcess.pid, 'SIGTERM');
+        },
+      });
+    }
+
+    return await done.promise;
+  }
+
+  public async exec(commandString: string): Promise<IExecResult> {
+    return (await this._exec({ commandString })) as IExecResult;
+  }
+
+  public async execSilent(commandString: string): Promise<IExecResult> {
+    return (await this._exec({ commandString, silent: true })) as IExecResult;
+  }
+
+  public async execStrict(commandString: string): Promise<IExecResult> {
+    return (await this._exec({ commandString, strict: true })) as IExecResult;
+  }
+
+  public async execStrictSilent(commandString: string): Promise<IExecResult> {
+    return (await this._exec({ commandString, silent: true, strict: true })) as IExecResult;
+  }
+
+  public async execStreaming(
+    commandString: string,
+    silent: boolean = false
+  ): Promise<IExecResultStreaming> {
+    return (await this._exec({ commandString, silent, streaming: true })) as IExecResultStreaming;
+  }
+
+  public async execStreamingSilent(commandString: string): Promise<IExecResultStreaming> {
+    return (await this._exec({
+      commandString,
+      silent: true,
+      streaming: true,
+    })) as IExecResultStreaming;
+  }
+
+  public async execInteractive(commandString: string) {
+    await this._exec({ commandString, interactive: true });
+  }
+
+  public async execAndWaitForLine(
+    commandString: string,
+    regexArg: RegExp,
+    silentArg: boolean = false
+  ) {
+    let done = plugins.smartpromise.defer();
+    let execStreamingResult = await this.execStreaming(commandString, silentArg);
+    execStreamingResult.childProcess.stdout.on('data', (stdOutChunk: string) => {
+      if (regexArg.test(stdOutChunk)) {
+        done.resolve();
+      }
+    });
+    return done.promise;
+  }
+
+  public async execAndWaitForLineSilent(commandString: string, regexArg: RegExp) {
+    return this.execAndWaitForLine(commandString, regexArg, true);
+  }
+}

package/ts/smartshell.plugins.ts

@@ -0,0 +1,11 @@
+import * as smartdelay from '@pushrocks/smartdelay';
+import * as smartexit from '@pushrocks/smartexit';
+import * as smartpromise from '@pushrocks/smartpromise';
+import which from 'which';
+
+export { smartdelay, smartexit, smartpromise, which };
+
+// third party
+import treeKill from 'tree-kill';
+
+export { treeKill };