2.0.21

.gitignore

@@ -1,4 +1,22 @@
+.nogit/
+
+# artifacts
 coverage/
-node_modules/
-pages/
 public/
+pages/
+
+# installs
+node_modules/
+
+# caches
+.yarn/
+.cache/
+.rpt2_cache
+
+# builds
+dist/
+dist_web/
+dist_serve/
+dist_ts_web/
+
+# custom

.gitlab-ci.yml

@@ -26,6 +26,7 @@ mirror:
 snyk:
   stage: security
   script:
+    - npmci npm prepare
     - npmci command npm install -g snyk
     - npmci command npm install --ignore-scripts
     - npmci command snyk test
@@ -36,21 +37,11 @@ snyk:
 # ====================
 # test stage
 # ====================
-testLEGACY:
-  stage: test
-  script:
-  - npmci node install legacy
-  - npmci npm install
-  - npmci npm test
-  coverage: /\d+.?\d+?\%\s*coverage/
-  tags:
-  - docker
-  - notpriv
-  allow_failure: true
 
 testLTS:
   stage: test
   script:
+  - npmci npm prepare
   - npmci node install lts
   - npmci npm install
   - npmci npm test
@@ -62,6 +53,7 @@ testLTS:
 testSTABLE:
   stage: test
   script:
+  - npmci npm prepare
   - npmci node install stable
   - npmci npm install
   - npmci npm test
@@ -117,8 +109,10 @@ pages:
   image: hosttoday/ht-docker-node:npmci
   stage: metadata
   script:
-    - npmci command npm install -g npmpage
-    - npmci command npmpage
+    - npmci command npm install -g @gitzone/tsdoc
+    - npmci npm prepare
+    - npmci npm install
+    - npmci command tsdoc
   tags:
     - docker
     - notpriv
@@ -129,13 +123,3 @@ pages:
     paths:
     - public
   allow_failure: true
-
-windowsCompatibility:
-  image: stefanscherer/node-windows:10-build-tools
-  stage: metadata
-  script:
-  - npm install & npm test
-  coverage: /\d+.?\d+?\%\s*coverage/
-  tags:
-  - windows
-  allow_failure: true

README.md

@@ -1,32 +1,28 @@
-# smartshell
-
+# @pushrocks/smartshell
 shell actions designed as promises
 
-## Availabililty
-
-[![npm](https://pushrocks.gitlab.io/assets/repo-button-npm.svg)](https://www.npmjs.com/package/smartshell)
-[![git](https://pushrocks.gitlab.io/assets/repo-button-git.svg)](https://GitLab.com/pushrocks/smartshell)
-[![git](https://pushrocks.gitlab.io/assets/repo-button-mirror.svg)](https://github.com/pushrocks/smartshell)
-[![docs](https://pushrocks.gitlab.io/assets/repo-button-docs.svg)](https://pushrocks.gitlab.io/smartshell/)
+## 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
-
-[![build status](https://GitLab.com/pushrocks/smartshell/badges/master/build.svg)](https://GitLab.com/pushrocks/smartshell/commits/master)
-[![coverage report](https://GitLab.com/pushrocks/smartshell/badges/master/coverage.svg)](https://GitLab.com/pushrocks/smartshell/commits/master)
-[![npm downloads per month](https://img.shields.io/npm/dm/smartshell.svg)](https://www.npmjs.com/package/smartshell)
-[![Dependency Status](https://david-dm.org/pushrocks/smartshell.svg)](https://david-dm.org/pushrocks/smartshell)
-[![bitHound Dependencies](https://www.bithound.io/github/pushrocks/smartshell/badges/dependencies.svg)](https://www.bithound.io/github/pushrocks/smartshell/master/dependencies/npm)
-[![bitHound Code](https://www.bithound.io/github/pushrocks/smartshell/badges/code.svg)](https://www.bithound.io/github/pushrocks/smartshell)
-[![TypeScript](https://img.shields.io/badge/TypeScript-2.x-blue.svg)](https://nodejs.org/dist/latest-v6.x/docs/api/)
-[![node](https://img.shields.io/badge/node->=%206.x.x-blue.svg)](https://nodejs.org/dist/latest-v6.x/docs/api/)
-[![JavaScript Style Guide](https://img.shields.io/badge/code%20style-standard-brightgreen.svg)](http://standardjs.com/)
+[![build status](https://gitlab.com/pushrocks/smartshell/badges/master/build.svg)](https://gitlab.com/pushrocks/smartshell/commits/master)
+[![coverage report](https://gitlab.com/pushrocks/smartshell/badges/master/coverage.svg)](https://gitlab.com/pushrocks/smartshell/commits/master)
+[![npm downloads per month](https://img.shields.io/npm/dm/@pushrocks/smartshell.svg)](https://www.npmjs.com/package/@pushrocks/smartshell)
+[![Known Vulnerabilities](https://snyk.io/test/npm/@pushrocks/smartshell/badge.svg)](https://snyk.io/test/npm/@pushrocks/smartshell)
+[![TypeScript](https://img.shields.io/badge/TypeScript->=%203.x-blue.svg)](https://nodejs.org/dist/latest-v10.x/docs/api/)
+[![node](https://img.shields.io/badge/node->=%2010.x.x-blue.svg)](https://nodejs.org/dist/latest-v10.x/docs/api/)
+[![JavaScript Style Guide](https://img.shields.io/badge/code%20style-prettier-ff69b4.svg)](https://prettier.io/)
 
 ## Usage
 
 Use TypeScript for best in class instellisense.
 
-For further information read the linked docs at the top of this README.
+For further information read the linked docs at the top of this readme.
 
 > MIT licensed | **©** [Lossless GmbH](https://lossless.gmbh)
+| By using this npm module you agree to our [privacy policy](https://lossless.gmbH/privacy.html)
 
-[![repo-footer](https://pushrocks.gitlab.io/assets/repo-footer.svg)](https://push.rocks)
+[![repo-footer](https://pushrocks.gitlab.io/assets/repo-footer.svg)](https://maintainedby.lossless.com)

npmextra.json

@@ -1,9 +1,17 @@
 {
   "npmci": {
-    "npmGlobalTools": [
-      "npmts",
-      "ts-node"
-    ],
-    "npmAccessLevel": "public"
+    "npmGlobalTools": [],
+    "npmAccessLevel": "public",
+    "npmRegistryUrl": "registry.npmjs.org"
+  },
+  "gitzone": {
+    "module": {
+      "githost": "gitlab.com",
+      "gitscope": "pushrocks",
+      "gitrepo": "smartshell",
+      "shortDescription": "shell actions designed as promises",
+      "npmPackagename": "@pushrocks/smartshell",
+      "license": "MIT"
+    }
   }
 }

package.json

@@ -1,13 +1,13 @@
 {
   "name": "@pushrocks/smartshell",
   "private": false,
-  "version": "2.0.1",
+  "version": "2.0.21",
   "description": "shell actions designed as promises",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
   "scripts": {
-    "test": "(tsrun test/test.ts)",
-    "build": "(npmts)"
+    "test": "(tstest test/)",
+    "build": "(tsbuild)"
   },
   "repository": {
     "type": "git",
@@ -24,12 +24,18 @@
   },
   "homepage": "https://gitlab.com/pushrocks/smartshell#README",
   "devDependencies": {
-    "@gitzone/tsrun": "^1.1.9",
-    "@pushrocks/tapbundle": "^3.0.1",
-    "@types/node": "^10.5.2"
+    "@gitzone/tsbuild": "^2.1.11",
+    "@gitzone/tsrun": "^1.2.6",
+    "@gitzone/tstest": "^1.0.23",
+    "@pushrocks/tapbundle": "^3.0.9",
+    "@types/node": "^12.0.2",
+    "tslint": "^5.16.0",
+    "tslint-config-prettier": "^1.18.0"
   },
   "dependencies": {
-    "@pushrocks/smartpromise": "^2.0.5",
+    "@pushrocks/smartdelay": "^2.0.3",
+    "@pushrocks/smartexit": "^1.0.15",
+    "@pushrocks/smartpromise": "^3.0.2",
     "@types/which": "^1.3.1",
     "which": "^1.3.1"
   }

test/test.ts

@@ -45,8 +45,12 @@ tap.test('smartshell should run async', async () => {
 });
 
 tap.test('should be able to find git', async () => {
-  testSmartshell.exec('git --version');
-})
+  await testSmartshell.exec('git --version');
+});
+
+tap.test('should spawn an interactive cli', async () => {
+  await testSmartshell.execInteractive('echo "hi"');
+});
 
 tap.start({
   throwOnError: true

ts/smartshell.classes.shellenv.ts

@@ -2,26 +2,63 @@ export type TExecutor = 'sh' | 'bash';
 
 export interface IShellEnvContructorOptions {
   executor: TExecutor;
-  sourceFilePaths: string[];
+  sourceFilePaths?: string[];
+  pathDirectories?: string[];
 }
 
 export class ShellEnv {
   executor: TExecutor;
   sourceFileArray: string[] = [];
-  
+  pathDirArray: string[] = [];
+
   /**
    * constructor for the shellenv
    */
   constructor(optionsArg: IShellEnvContructorOptions) {
     this.executor = optionsArg.executor;
-    for (let sourceFilePath of optionsArg.sourceFilePaths) {
-      this.sourceFileArray.push(sourceFilePath);
+
+    // 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 {
+    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 
+   * @param sourceFilePathsArray
    */
   addSourceFiles(sourceFilePathsArray: string[]) {
     for (let sourceFilePath of sourceFilePathsArray) {
@@ -36,15 +73,31 @@ export class ShellEnv {
     this.sourceFileArray = [];
   }
 
-  createEnvExecString(commandArg): string {
-    if (this.executor === 'bash') {
-      let sourceString = '';
-      for (let sourceFilePath of this.sourceFileArray) {
-        sourceString = sourceString + `source ${sourceFilePath} && `;
-      }
-      return `bash -c '${sourceString} ${commandArg}'`;
-    } else {
-      return commandArg;
+  public createEnvExecString(commandArg: string): string {
+    let commandResult = '';
+    let sourceString = '';
+
+    // deal with sourcestring
+    for (const sourceFilePath of this.sourceFileArray) {
+      sourceString = sourceString + `source ${sourceFilePath} && `;
     }
+
+    // deal with avaiable 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;
   }
-}
+}

ts/smartshell.classes.shelllog.ts

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

ts/smartshell.classes.smartshell.ts

@@ -1,11 +1,10 @@
 // -- imports --
 import * as plugins from './smartshell.plugins';
-import * as smartshellWrap from './smartshell.wrap';
-import { ShellEnv, IShellEnvContructorOptions, TExecutor, } from './smartshell.classes.shellenv';
+import { ShellEnv, IShellEnvContructorOptions, TExecutor } from './smartshell.classes.shellenv';
 import { ShellLog } from './smartshell.classes.shelllog';
 
-import * as cp from "child_process";
-import { Deferred } from "@pushrocks/smartpromise";
+import * as cp from 'child_process';
+import { Deferred } from '@pushrocks/smartpromise';
 
 // -- interfaces --
 /**
@@ -22,34 +21,23 @@ export interface IExecResult {
 export interface IExecResultStreaming {
   childProcess: cp.ChildProcess;
   finalPromise: Promise<IExecResult>;
+  kill: () => void;
 }
 
 // -- SmartShell --
 export class Smartshell {
-  shellEnv: ShellEnv;
+  public shellEnv: ShellEnv;
+  public smartexit = new plugins.smartexit.SmartExit();
 
   constructor(optionsArg: IShellEnvContructorOptions) {
     this.shellEnv = new ShellEnv(optionsArg);
   }
 
-  /**
-   * imports path into the shell from env if available and returns it with
-   */
-  private _importEnvVarPath (stringArg): string {
-    if (process.env.SMARTSHELL_PATH) {
-      let commandResult = `PATH=${process.env.SMARTSHELL_PATH} && ${stringArg}`;
-      // console.log(commandResult)
-      return commandResult;
-    } else {
-      return stringArg;
-    }
-  };
-
   /**
    * executes a given command async
    * @param commandStringArg
    */
-  private async _exec (
+  private async _exec(
     commandStringArg: string,
     silentArg: boolean = false,
     strictArg = false,
@@ -59,46 +47,53 @@ export class Smartshell {
     const done = plugins.smartpromise.defer<IExecResult | IExecResultStreaming>();
     const childProcessEnded = plugins.smartpromise.defer<IExecResult>();
     // build commandToExecute
-    let commandToExecute = commandStringArg
+    let commandToExecute = commandStringArg;
     commandToExecute = this.shellEnv.createEnvExecString(commandStringArg);
-    commandToExecute = this._importEnvVarPath(commandToExecute);
     const spawnlogInstance = new ShellLog();
     const execChildProcess = cp.spawn(commandToExecute, [], {
       shell: true,
-      env: process.env
+      env: process.env,
+      detached: false
     });
 
-    execChildProcess.stdout.on("data", data => {
+    this.smartexit.addProcess(execChildProcess);
+
+    execChildProcess.stdout.on('data', data => {
       if (!silentArg) {
-        spawnlogInstance.logToConsole(data);
+        spawnlogInstance.writeToConsole(data);
       }
       spawnlogInstance.addToBuffer(data);
     });
-    execChildProcess.stderr.on("data", data => {
+    execChildProcess.stderr.on('data', data => {
       if (!silentArg) {
-        spawnlogInstance.logToConsole(data);
+        spawnlogInstance.writeToConsole(data);
       }
       spawnlogInstance.addToBuffer(data);
     });
 
-    if(streamingArg) {
+    if (streamingArg) {
       done.resolve({
         childProcess: execChildProcess,
-        finalPromise: childProcessEnded.promise
+        finalPromise: childProcessEnded.promise,
+        kill: () => {
+          // this notation with the - kills the whole process group
+          process.kill(-execChildProcess.pid);
+        }
       });
     }
 
-    execChildProcess.on("exit", (code, signal) => {
-      if(strictArg && code === 1) {
+    execChildProcess.on('exit', (code, signal) => {
+      this.smartexit.removeProcess(execChildProcess);
+      if (strictArg && code === 1) {
         done.reject();
       }
 
       const execResult = {
         exitCode: code,
         stdout: spawnlogInstance.logStore.toString()
-      }
+      };
 
-      if(!streamingArg) {
+      if (!streamingArg) {
         done.resolve(execResult);
       }
       childProcessEnded.resolve(execResult);
@@ -106,72 +101,82 @@ export class Smartshell {
 
     const result = await done.promise;
     return result;
-  };
+  }
 
-  async exec (
-    commandStringArg: string
-  ): Promise<IExecResult> {
+  public async exec(commandStringArg: string): Promise<IExecResult> {
     return (await this._exec(commandStringArg, false)) as IExecResult;
-  };
-  
+  }
+
   /**
    * executes a given command async and silent
    * @param commandStringArg
    */
-  async execSilent (
-    commandStringArg: string
-  ): Promise<IExecResult> {
+  public async execSilent(commandStringArg: string): Promise<IExecResult> {
     return (await this._exec(commandStringArg, true)) as IExecResult;
-  };
+  }
 
   /**
    * executes a command async and strict, meaning it rejects the promise if something happens
    */
-  async execStrict (
-    commandStringArg: string
-  ): Promise<IExecResult> {
-    return (await this._exec(commandStringArg, true, true))  as IExecResult;
-  };
+  public async execStrict(commandStringArg: string): Promise<IExecResult> {
+    return (await this._exec(commandStringArg, true, true)) as IExecResult;
+  }
 
   /**
    * executes a command and allows you to stream output
    */
-  async execStreaming (
+  public async execStreaming(
     commandStringArg: string,
     silentArg: boolean = false
   ): Promise<IExecResultStreaming> {
     return (await this._exec(commandStringArg, silentArg, false, true)) as IExecResultStreaming;
-  };
+  }
 
-  async execStreamingSilent (commandStringArg: string) {
+  public async execStreamingSilent(commandStringArg: string) {
     return (await this.execStreaming(commandStringArg, true)) as IExecResultStreaming;
-  };
+  }
 
   /**
    * executes a command and returns promise that will be fullfilled once an putput line matches RegexArg
    * @param commandStringArg
    * @param regexArg
    */
-  async execAndWaitForLine (
+  public async execAndWaitForLine(
     commandStringArg: string,
     regexArg: RegExp,
     silentArg: boolean = false
   ) {
     let done = plugins.smartpromise.defer();
     let execStreamingResult = await this.execStreaming(commandStringArg, silentArg);
-    execStreamingResult.childProcess.stdout.on("data", (stdOutChunk: string) => {
+    execStreamingResult.childProcess.stdout.on('data', (stdOutChunk: string) => {
       if (regexArg.test(stdOutChunk)) {
         done.resolve();
       }
     });
     return done.promise;
-  };
+  }
 
-  async execAndWaitForLineSilent (
-    commandStringArg: string,
-    regexArg: RegExp
-  ) {
+  public async execAndWaitForLineSilent(commandStringArg: string, regexArg: RegExp) {
     this.execAndWaitForLine(commandStringArg, regexArg, true);
-  };
-  
+  }
+
+  /**
+   * execs an command and then enters interactive CLI
+   * @param commandStringArg
+   * @param regexArg
+   */
+  public async execInteractive(commandStringArg: string) {
+    const done = plugins.smartpromise.defer();
+    const shell = cp.spawn('sh', [], { stdio: 'pipe' });
+    this.smartexit.addProcess(shell);
+    const shellLog = new ShellLog();
+    process.stdin.pipe(shell.stdin);
+    shell.stdout.pipe(process.stdout);
+    shell.on('close', code => {
+      console.log(`interactive shell terminated with code ${code}`);
+      done.resolve();
+    });
+    shell.stdin.write(commandStringArg + '\n');
+    await done.promise;
+  }
 }

ts/smartshell.plugins.ts

@@ -1,4 +1,6 @@
+import * as smartdelay from '@pushrocks/smartdelay';
+import * as smartexit from '@pushrocks/smartexit';
 import * as smartpromise from '@pushrocks/smartpromise';
 import * as which from 'which';
 
-export { smartpromise, which };
+export { smartdelay, smartexit, smartpromise, which };

ts/smartshell.wrap.ts

@@ -1,59 +0,0 @@
-import * as plugins from "./smartshell.plugins";
-import { ShellLog } from "./smartshell.classes.shelllog";
-
-// interfaces
-import * as cp from "child_process";
-import { Deferred } from "@pushrocks/smartpromise";
-
-/**
- * interface for ExecResult
- */
-export interface IExecResult {
-  exitCode: number;
-  stdout: string;
-}
-
-/**
- * interface for streaming ExecResult
- */
-export interface IExecResultStreaming {
-  childProcess: cp.ChildProcess;
-  finalPromise: Promise<IExecResult>;
-}
-
-
-
-/**
- * get a path
- */
-export let which = (cmd: string): Promise<string> => {
-  let done = plugins.smartpromise.defer<string>();
-  plugins.which(cmd, (err, path: string) => {
-    if (err) {
-      done.reject(err);
-    }
-    done.resolve(path);
-  });
-  return done.promise;
-};
-
-
-/* /////////////////////////////////////////////////////////
-
-/**
-   * executes silently and returns IExecResult
-   * @param commandArg
-   
-  async execSilent(commandArg: string) {
-    let execCommand = this..createExecString(commandArg);
-    return await smartshellWrap.execSilent(execCommand);
-  }
-
-  /**
-   * executes and returns IExecResult
-   * @param commandArg
-   
-  async exec(commandArg: string) {
-    let execCommand = this.createExecString(commandArg);
-    return await smartshellWrap.exec(execCommand);
-  } */

tslint.json

@@ -1,3 +1,17 @@
 {
-    "extends": "tslint-config-standard"
+  "extends": ["tslint:latest", "tslint-config-prettier"],
+  "rules": {
+    "semicolon": [true, "always"],
+    "no-console": false,
+    "ordered-imports": false,
+    "object-literal-sort-keys": false,
+    "member-ordering": {
+      "options":{
+        "order": [
+          "static-method"
+        ]
+      }
+    }
+  },
+  "defaultSeverity": "warning"
 }