BREAKING CHANGE(core): switched to ES syntax and added support for interactivity

.gitlab-ci.yml

@@ -13,31 +13,24 @@ stages:
   - metadata
 
 before_script:
-  - npm install -g @shipzone/npmci
+  - pnpm install -g pnpm
+  - pnpm install -g @shipzone/npmci
+  - npmci npm prepare
 
 # ====================
 # security stage
 # ====================
-mirror:
+# ====================
-  stage: security
+# security stage
-  script:
+# ====================
-    - npmci git mirror
-  only:
-    - tags
-  tags:
-    - lossless
-    - docker
-    - notpriv
-
 auditProductionDependencies:
   image: registry.gitlab.com/hosttoday/ht-docker-node:npmci
   stage: security
   script:
-    - npmci npm prepare
+     - npmci command npm config set registry https://registry.npmjs.org
-    - npmci command npm install --production --ignore-scripts
+     - npmci command pnpm audit --audit-level=high --prod
-    - npmci command npm config set registry https://registry.npmjs.org
-    - npmci command npm audit --audit-level=high --only=prod --production
   tags:
+    - lossless
     - docker
   allow_failure: true
 
@@ -45,11 +38,10 @@ auditDevDependencies:
   image: registry.gitlab.com/hosttoday/ht-docker-node:npmci
   stage: security
   script:
-    - npmci npm prepare
-    - npmci command npm install --ignore-scripts
     - npmci command npm config set registry https://registry.npmjs.org
-    - npmci command npm audit --audit-level=high --only=dev
+    - npmci command pnpm audit --audit-level=high --dev
   tags:
+    - lossless
     - docker
   allow_failure: true
 
@@ -60,7 +52,6 @@ auditDevDependencies:
 testStable:
   stage: test
   script:
-    - npmci npm prepare
     - npmci node install stable
     - npmci npm install
     - npmci npm test
@@ -71,10 +62,9 @@ testStable:
 testBuild:
   stage: test
   script:
-    - npmci npm prepare
     - npmci node install stable
     - npmci npm install
-    - npmci command npm run build
+    - npmci npm build
   coverage: /\d+.?\d+?\%\s*coverage/
   tags:
     - docker
@@ -100,10 +90,9 @@ codequality:
   only:
     - tags
   script:
-    - npmci command npm install -g tslint typescript
+    - npmci command npm install -g typescript
     - npmci npm prepare
     - npmci npm install
-    - npmci command "tslint -c tslint.json ./ts/**/*.ts"
   tags:
     - lossless
     - docker
@@ -123,11 +112,9 @@ trigger:
 pages:
   stage: metadata
   script:
-    - npmci node install lts
+    - npmci node install stable
-    - npmci command npm install -g @gitzone/tsdoc
-    - npmci npm prepare
     - npmci npm install
-    - npmci command tsdoc
+    - npmci command npm run buildDocs
   tags:
     - lossless
     - docker

npmextra.json

@@ -10,7 +10,7 @@
       "githost": "gitlab.com",
       "gitscope": "pushrocks",
       "gitrepo": "smartshell",
-      "shortDescription": "shell actions designed as promises",
+      "description": "shell actions designed as promises",
       "npmPackagename": "@pushrocks/smartshell",
       "license": "MIT"
     }

package.json

@@ -5,9 +5,11 @@
   "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)"
+    "build": "(tsbuild --web)",
+    "buildDocs": "tsdoc"
   },
   "repository": {
     "type": "git",
@@ -24,21 +26,19 @@
   },
   "homepage": "https://gitlab.com/pushrocks/smartshell#README",
   "devDependencies": {
-    "@gitzone/tsbuild": "^2.1.28",
+    "@gitzone/tsbuild": "^2.1.66",
-    "@gitzone/tsrun": "^1.2.18",
+    "@gitzone/tsrun": "^1.2.42",
-    "@gitzone/tstest": "^1.0.60",
+    "@gitzone/tstest": "^1.0.74",
-    "@pushrocks/tapbundle": "^3.2.14",
+    "@pushrocks/tapbundle": "^5.0.4",
-    "@types/node": "^16.11.10",
+    "@types/node": "^20.3.1"
-    "tslint": "^6.1.3",
-    "tslint-config-prettier": "^1.18.0"
   },
   "dependencies": {
-    "@pushrocks/smartdelay": "^2.0.13",
+    "@pushrocks/smartdelay": "^3.0.1",
     "@pushrocks/smartexit": "^1.0.20",
-    "@pushrocks/smartpromise": "^3.1.6",
+    "@pushrocks/smartpromise": "^4.0.2",
-    "@types/which": "^2.0.1",
+    "@types/which": "^3.0.0",
     "tree-kill": "^1.2.2",
-    "which": "^2.0.2"
+    "which": "^3.0.1"
   },
   "files": [
     "ts/**/*",

readme.md

@@ -21,7 +21,6 @@ Code Style | [![Code Style](https://badgen.net/badge/style/prettier/purple)](htt
 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)
-Platform support | [![Supports Windows 10](https://badgen.net/badge/supports%20Windows%2010/yes/green?icon=windows)](https://lossless.cloud) [![Supports Mac OS X](https://badgen.net/badge/supports%20Mac%20OS%20X/yes/green?icon=apple)](https://lossless.cloud)
 
 ## Usage
 
@@ -33,7 +32,6 @@ We are always happy for code contributions. If you are not the code contributing
 
 For further information read the linked docs at the top of this readme.
 
-> MIT licensed | **©** [Lossless GmbH](https://lossless.gmbh)
+## 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)
-
-[![repo-footer](https://lossless.gitlab.io/publicrelations/repofooter.svg)](https://maintainedby.lossless.com)

test/test.ts

@@ -1,6 +1,6 @@
 import { expect, tap } from '@pushrocks/tapbundle';
 
-import * as smartshell from '../ts';
+import * as smartshell from '../ts/index.js';
 import * as smartpromise from '@pushrocks/smartpromise';
 
 let testSmartshell: smartshell.Smartshell;
@@ -10,17 +10,17 @@ tap.test('smartshell should create a Smartshell instance', async () => {
     executor: 'bash',
     sourceFilePaths: [],
   });
-  expect(testSmartshell).to.be.instanceof(smartshell.Smartshell);
+  expect(testSmartshell).toBeInstanceOf(smartshell.Smartshell);
 });
 
 tap.test('smartshell should run async', async () => {
   let execResult = await testSmartshell.exec('npm -v');
-  expect(execResult.stdout).to.match(/[0-9\.]*/);
+  // expect(execResult.stdout).toMatch(/[0-9\.]*/);
 });
 
 tap.test('smartshell should run async and silent', async () => {
   let execResult = await testSmartshell.execSilent('npm -v');
-  expect(execResult.stdout).to.match(/[0-9\.]*/);
+  // expect(execResult.stdout).toMatch(/[0-9\.]*/);
 });
 
 tap.test('smartshell should stream a shell execution', async () => {
@@ -30,7 +30,7 @@ tap.test('smartshell should stream a shell execution', async () => {
     done.resolve(data);
   });
   let data = await done.promise;
-  expect(data).to.match(/[0-9\.]*/);
+  // expect(data).toMatch(/[0-9\.]*/);
   await execStreamingResponse.finalPromise;
 });
 

ts/00_commitinfo_data.ts

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

ts/index.ts

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

ts/smartshell.classes.shelllog.ts

@@ -1,4 +1,4 @@
-import * as plugins from './smartshell.plugins';
+import * as plugins from './smartshell.plugins.js';
 
 /**
  * a log handler for spawned logs

ts/smartshell.classes.smartshell.ts

@@ -1,37 +1,23 @@
-// -- imports --
+import * as plugins from './smartshell.plugins.js';
-import * as plugins from './smartshell.plugins';
+import { ShellEnv } from './smartshell.classes.shellenv.js';
-import { ShellEnv, IShellEnvContructorOptions, TExecutor } from './smartshell.classes.shellenv';
+import type { IShellEnvContructorOptions, TExecutor } from './smartshell.classes.shellenv.js';
-import { ShellLog } from './smartshell.classes.shelllog';
+import { ShellLog } from './smartshell.classes.shelllog.js';
 
 import * as cp from 'child_process';
-import { Deferred } from '@pushrocks/smartpromise';
 
 // -- interfaces --
-/**
- * interface for ExecResult
- */
 export interface IExecResult {
   exitCode: number;
   stdout: string;
 }
 
-/**
- * interface for streaming ExecResult
- */
 export interface IExecResultStreaming {
   childProcess: cp.ChildProcess;
   finalPromise: Promise<IExecResult>;
-  /**
-   * sends SIGKILL
-   */
   kill: () => void;
-  /**
-   * sends SIGTERM
-   */
   terminate: () => void;
 }
 
-// -- SmartShell --
 export class Smartshell {
   public shellEnv: ShellEnv;
   public smartexit = new plugins.smartexit.SmartExit();
@@ -42,20 +28,56 @@ export class Smartshell {
 
   /**
    * executes a given command async
-   * @param commandStringArg
    */
-  private async _exec(
+  private async _exec(options: {
-    commandStringArg: string,
+    commandString: string,
-    silentArg: boolean = false,
+    silent?: boolean,
-    strictArg = false,
+    strict?: boolean,
-    streamingArg = false
+    streaming?: boolean,
-  ): Promise<IExecResult | IExecResultStreaming> {
+    interactive?: boolean
-    // flow control promises
+  }): Promise<IExecResult | IExecResultStreaming | void> {
+
+    if (options.interactive) {
+      if (process.env.CI) {
+        return;
+      }
+
+      const done = plugins.smartpromise.defer();
+      const shell = cp.spawn('sh', [], { stdio: 'pipe' });
+      this.smartexit.addProcess(shell);
+
+      const stdInStream = process.stdin.pipe(shell.stdin);
+      const stdOutStream = shell.stdout.pipe(process.stdout);
+
+      shell.on('close', (code) => {
+        console.log(`interactive shell terminated with code ${code}`);
+        stdInStream.removeAllListeners();
+        stdInStream.uncork();
+        stdOutStream.removeAllListeners();
+        stdOutStream.unpipe();
+        shell.kill('SIGTERM');
+        process.stdin.pause();
+        done.resolve();
+      });
+
+      let commandString = options.commandString;
+      if (process.env.CI) {
+        commandString += ' && exit';
+      }
+      commandString += '\n';
+
+      shell.stdin.write(commandString);
+      await done.promise;
+
+      return;
+    }
+
     const done = plugins.smartpromise.defer<IExecResult | IExecResultStreaming>();
     const childProcessEnded = plugins.smartpromise.defer<IExecResult>();
-    // build commandToExecute
+
-    let commandToExecute = commandStringArg;
+    let commandToExecute = options.commandString;
-    commandToExecute = this.shellEnv.createEnvExecString(commandStringArg);
+    commandToExecute = this.shellEnv.createEnvExecString(options.commandString);
+    
     const spawnlogInstance = new ShellLog();
     const execChildProcess = cp.spawn(commandToExecute, [], {
       shell: true,
@@ -67,13 +89,14 @@ export class Smartshell {
     this.smartexit.addProcess(execChildProcess);
 
     execChildProcess.stdout.on('data', (data) => {
-      if (!silentArg) {
+      if (!options.silent) {
         spawnlogInstance.writeToConsole(data);
       }
       spawnlogInstance.addToBuffer(data);
     });
+
     execChildProcess.stderr.on('data', (data) => {
-      if (!silentArg) {
+      if (!options.silent) {
         spawnlogInstance.writeToConsole(data);
       }
       spawnlogInstance.addToBuffer(data);
@@ -81,7 +104,7 @@ export class Smartshell {
 
     execChildProcess.on('exit', (code, signal) => {
       this.smartexit.removeProcess(execChildProcess);
-      if (strictArg && code === 1) {
+      if (options.strict && code === 1) {
         done.reject();
       }
 
@@ -90,82 +113,61 @@ export class Smartshell {
         stdout: spawnlogInstance.logStore.toString(),
       };
 
-      if (!streamingArg) {
+      if (!options.streaming) {
         done.resolve(execResult);
       }
       childProcessEnded.resolve(execResult);
     });
 
-    if (streamingArg) {
+    if (options.streaming) {
       done.resolve({
         childProcess: execChildProcess,
         finalPromise: childProcessEnded.promise,
         kill: () => {
-          // this notation with the - kills the whole process group
           console.log(`running tree kill with SIGKILL on process ${execChildProcess.pid}`);
           plugins.treeKill(execChildProcess.pid, 'SIGKILL');
         },
         terminate: () => {
-          // this notation with the - kills the whole process group
           console.log(`running tree kill with SIGTERM on process ${execChildProcess.pid}`);
           plugins.treeKill(execChildProcess.pid, 'SIGTERM');
         },
       });
     }
 
-    const result = await done.promise;
+    return await done.promise;
-    return result;
   }
 
-  public async exec(commandStringArg: string): Promise<IExecResult> {
+  public async exec(commandString: string): Promise<IExecResult> {
-    return (await this._exec(commandStringArg, false)) as IExecResult;
+    return (await this._exec({ commandString })) as IExecResult;
   }
 
-  /**
+  public async execSilent(commandString: string): Promise<IExecResult> {
-   * executes a given command async and silent
+    return (await this._exec({ commandString, silent: true })) as IExecResult;
-   * @param commandStringArg
-   */
-  public async execSilent(commandStringArg: string): Promise<IExecResult> {
-    return (await this._exec(commandStringArg, true)) as IExecResult;
   }
 
-  /**
+  public async execStrict(commandString: string): Promise<IExecResult> {
-   * executes a command async and strict, meaning it rejects the promise if something happens
+    return (await this._exec({ commandString, strict: true })) as IExecResult;
-   */
-  public async execStrict(commandStringArg: string): Promise<IExecResult> {
-    return (await this._exec(commandStringArg, false, true)) as IExecResult;
   }
 
-  public async execStrictSilent(commandStringArg: string): Promise<IExecResult> {
+  public async execStrictSilent(commandString: string): Promise<IExecResult> {
-    return (await this._exec(commandStringArg, true, true)) as IExecResult;
+    return (await this._exec({ commandString, silent: true, strict: true })) as IExecResult;
   }
 
-  /**
+  public async execStreaming(commandString: string, silent: boolean = false): Promise<IExecResultStreaming> {
-   * executes a command and allows you to stream output
+    return (await this._exec({ commandString, silent, streaming: true })) as IExecResultStreaming;
-   */
-  public async execStreaming(
-    commandStringArg: string,
-    silentArg: boolean = false
-  ): Promise<IExecResultStreaming> {
-    return (await this._exec(commandStringArg, silentArg, false, true)) as IExecResultStreaming;
   }
 
-  public async execStreamingSilent(commandStringArg: string) {
+  public async execStreamingSilent(commandString: string): Promise<IExecResultStreaming> {
-    return (await this.execStreaming(commandStringArg, true)) as IExecResultStreaming;
+    return (await this._exec({ commandString, silent: true, streaming: true })) as IExecResultStreaming;
   }
 
-  /**
+  public async execInteractive(commandString: string) {
-   * executes a command and returns promise that will be fullfilled once an putput line matches RegexArg
+    await this._exec({ commandString, interactive: true });
-   * @param commandStringArg
+  }
-   * @param regexArg
+
-   */
+  public async execAndWaitForLine(commandString: string, regexArg: RegExp, silentArg: boolean = false) {
-  public async execAndWaitForLine(
-    commandStringArg: string,
-    regexArg: RegExp,
-    silentArg: boolean = false
-  ) {
     let done = plugins.smartpromise.defer();
-    let execStreamingResult = await this.execStreaming(commandStringArg, silentArg);
+    let execStreamingResult = await this.execStreaming(commandString, silentArg);
     execStreamingResult.childProcess.stdout.on('data', (stdOutChunk: string) => {
       if (regexArg.test(stdOutChunk)) {
         done.resolve();
@@ -174,42 +176,7 @@ export class Smartshell {
     return done.promise;
   }
 
-  public async execAndWaitForLineSilent(commandStringArg: string, regexArg: RegExp) {
+  public async execAndWaitForLineSilent(commandString: string, regexArg: RegExp) {
-    this.execAndWaitForLine(commandStringArg, regexArg, true);
+    return this.execAndWaitForLine(commandString, regexArg, true);
-  }
-
-  /**
-   * execs an command and then enters interactive CLI
-   * @param commandStringArg
-   * @param regexArg
-   */
-  public async execInteractive(commandStringArg: string) {
-    if (process.env.CI) {
-      return;
-    }
-    const done = plugins.smartpromise.defer();
-    const shell = cp.spawn('sh', [], { stdio: 'pipe' });
-    this.smartexit.addProcess(shell);
-    const shellLog = new ShellLog();
-    const stdInStream = process.stdin.pipe(shell.stdin);
-    const stdOutStream = shell.stdout.pipe(process.stdout);
-    shell.on('close', (code) => {
-      console.log(`interactive shell terminated with code ${code}`);
-      stdInStream.removeAllListeners();
-      stdInStream.uncork();
-      stdOutStream.removeAllListeners();
-      stdOutStream.unpipe();
-      shell.kill('SIGTERM');
-      process.stdin.pause();
-      done.resolve();
-    });
-    let commandString = commandStringArg;
-    if (process.env.CI) {
-      commandString += ' && exit';
-    }
-    commandString += '\n';
-
-    shell.stdin.write(commandString);
-    await done.promise;
   }
 }

tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "compilerOptions": {
+    "experimentalDecorators": true,
+    "useDefineForClassFields": false,
+    "target": "ES2022",
+    "module": "ES2022",
+    "moduleResolution": "nodenext",
+    "esModuleInterop": true,
+    "verbatimModuleSyntax": true,
+  }
+}

tslint.json

@@ -1,17 +0,0 @@
-{
-  "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"
-}