@push.rocks/smartshell 3.0.6 → 3.2.0

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@push.rocks/smartshell',
-    version: '3.0.6',
+    version: '3.2.0',
     description: 'A library for executing shell commands using promises.'
 };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSx3QkFBd0I7SUFDOUIsT0FBTyxFQUFFLE9BQU87SUFDaEIsV0FBVyxFQUFFLHdEQUF3RDtDQUN0RSxDQUFBIn0=

package/dist_ts/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/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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xhc3Nlcy5zaGVsbGVudi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL2NsYXNzZXMuc2hlbGxlbnYudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBUUEsTUFBTSxPQUFPLFFBQVE7SUFLbkI7O09BRUc7SUFDSCxZQUFZLFVBQXNDO1FBTmxELG9CQUFlLEdBQWEsRUFBRSxDQUFDO1FBQy9CLGlCQUFZLEdBQWEsRUFBRSxDQUFDO1FBTTFCLElBQUksQ0FBQyxRQUFRLEdBQUcsVUFBVSxDQUFDLFFBQVEsQ0FBQztRQUVwQyxrQkFBa0I7UUFDbEIsSUFBSSxVQUFVLENBQUMsZUFBZSxFQUFFLENBQUM7WUFDL0IsSUFBSSxDQUFDLGVBQWUsR0FBRyxJQUFJLENBQUMsZUFBZSxDQUFDLE1BQU0sQ0FBQyxVQUFVLENBQUMsZUFBZSxDQUFDLENBQUM7UUFDakYsQ0FBQztRQUVELHNCQUFzQjtRQUN0QixJQUFJLFVBQVUsQ0FBQyxlQUFlLEVBQUUsQ0FBQztZQUMvQixJQUFJLENBQUMsWUFBWSxHQUFHLElBQUksQ0FBQyxZQUFZLENBQUMsTUFBTSxDQUFDLFVBQVUsQ0FBQyxlQUFlLENBQUMsQ0FBQztRQUMzRSxDQUFDO0lBQ0gsQ0FBQztJQUVEOztPQUVHO0lBQ0ssUUFBUSxDQUFDLGdCQUF3QjtRQUN2QyxJQUFJLGFBQWEsR0FBRyxnQkFBZ0IsQ0FBQztRQUNyQyxJQUFJLFlBQVksR0FBYSxFQUFFLENBQUM7UUFDaEMsWUFBWSxHQUFHLFlBQVksQ0FBQyxNQUFNLENBQUMsT0FBTyxDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUM7UUFDaEUsSUFBSSxPQUFPLENBQUMsR0FBRyxDQUFDLGVBQWUsRUFBRSxDQUFDO1lBQ2hDLFlBQVksR0FBRyxZQUFZLENBQUMsTUFBTSxDQUFDLE9BQU8sQ0FBQyxHQUFHLENBQUMsZUFBZSxDQUFDLEtBQUssQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDO1FBQzdFLENBQUM7UUFFRCxpQ0FBaUM7UUFDakMsY0FBYztRQUNkLFlBQVksR0FBRyxZQUFZLENBQUMsTUFBTSxDQUFDLENBQUMsY0FBYyxFQUFFLEVBQUU7WUFDcEQsTUFBTSxZQUFZLEdBQ2hCLENBQUMsY0FBYyxDQUFDLFVBQVUsQ0FBQyxTQUFTLENBQUM7Z0JBQ3JDLENBQUMsY0FBYyxDQUFDLFVBQVUsQ0FBQyxVQUFVLENBQUM7Z0JBQ3RDLENBQUMsY0FBYyxDQUFDLFFBQVEsQ0FBQyxHQUFHLENBQUMsQ0FBQztZQUNoQyxJQUFJLENBQUMsWUFBWSxFQUFFLENBQUM7Z0JBQ2xCLHNEQUFzRDtZQUN4RCxDQUFDO1lBQ0QsT0FBTyxZQUFZLENBQUM7UUFDdEIsQ0FBQyxDQUFDLENBQUM7UUFFSCxhQUFhLEdBQUcsUUFBUSxZQUFZLENBQUMsSUFBSSxDQUFDLEdBQUcsQ0FBQyxPQUFPLGdCQUFnQixFQUFFLENBQUM7UUFDeEUsT0FBTyxhQUFhLENBQUM7SUFDdkIsQ0FBQztJQUVEOzs7T0FHRztJQUNILGNBQWMsQ0FBQyxvQkFBOEI7UUFDM0MsS0FBSyxJQUFJLGNBQWMsSUFBSSxvQkFBb0IsRUFBRSxDQUFDO1lBQ2hELElBQUksQ0FBQyxlQUFlLENBQUMsSUFBSSxDQUFDLGNBQWMsQ0FBQyxDQUFDO1FBQzVDLENBQUM7SUFDSCxDQUFDO0lBRUQ7O09BRUc7SUFDSCxnQkFBZ0I7UUFDZCxJQUFJLENBQUMsZUFBZSxHQUFHLEVBQUUsQ0FBQztJQUM1QixDQUFDO0lBRU0sbUJBQW1CLENBQUMsVUFBa0I7UUFDM0MsSUFBSSxhQUFhLEdBQUcsRUFBRSxDQUFDO1FBQ3ZCLElBQUksWUFBWSxHQUFHLEVBQUUsQ0FBQztRQUV0Qix5QkFBeUI7UUFDekIsS0FBSyxNQUFNLGNBQWMsSUFBSSxJQUFJLENBQUMsZUFBZSxFQUFFLENBQUM7WUFDbEQsWUFBWSxHQUFHLFlBQVksR0FBRyxVQUFVLGNBQWMsTUFBTSxDQUFDO1FBQy9ELENBQUM7UUFFRCwyQkFBMkI7UUFDM0IsSUFBSSxVQUFVLEdBQUcsWUFBWSxDQUFDO1FBQzlCLEtBQUssTUFBTSxPQUFPLElBQUksSUFBSSxDQUFDLFlBQVksRUFBRSxDQUFDO1lBQ3hDLFVBQVUsSUFBSSxJQUFJLE9BQU8sRUFBRSxDQUFDO1FBQzlCLENBQUM7UUFDRCxVQUFVLElBQUksTUFBTSxDQUFDO1FBRXJCLFFBQVEsSUFBSSxDQUFDLFFBQVEsRUFBRSxDQUFDO1lBQ3RCLEtBQUssTUFBTTtnQkFDVCxhQUFhLEdBQUcsWUFBWSxVQUFVLEdBQUcsWUFBWSxHQUFHLFVBQVUsR0FBRyxDQUFDO2dCQUN0RSxNQUFNO1lBQ1IsS0FBSyxJQUFJO2dCQUNQLGFBQWEsR0FBRyxHQUFHLFVBQVUsR0FBRyxZQUFZLEdBQUcsVUFBVSxFQUFFLENBQUM7Z0JBQzVELE1BQU07UUFDVixDQUFDO1FBQ0QsYUFBYSxHQUFHLElBQUksQ0FBQyxRQUFRLENBQUMsYUFBYSxDQUFDLENBQUM7UUFDN0MsT0FBTyxhQUFhLENBQUM7SUFDdkIsQ0FBQztDQUNGIn0=

package/dist_ts/classes.shelllog.d.ts

@@ -0,0 +1,18 @@
+/**
+ * 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/classes.shelllog.js

@@ -0,0 +1,37 @@
+import * as plugins from './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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xhc3Nlcy5zaGVsbGxvZy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL2NsYXNzZXMuc2hlbGxsb2cudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLE9BQU8sTUFBTSxjQUFjLENBQUM7QUFFeEM7OztHQUdHO0FBQ0gsTUFBTSxPQUFPLFFBQVE7SUFBckI7UUFDUyxhQUFRLEdBQUcsTUFBTSxDQUFDLElBQUksQ0FBQyxFQUFFLENBQUMsQ0FBQztJQThCcEMsQ0FBQztJQTVCQzs7O09BR0c7SUFDSSxjQUFjLENBQUMsT0FBd0I7UUFDNUMsdUNBQXVDO1FBQ3ZDLE9BQU8sQ0FBQyxNQUFNLENBQUMsS0FBSyxDQUFDLE9BQU8sQ0FBQyxDQUFDO0lBQ2hDLENBQUM7SUFFRDs7O09BR0c7SUFDSSxXQUFXLENBQUMsT0FBd0I7UUFDekMsdUNBQXVDO1FBQ3ZDLE1BQU0sVUFBVSxHQUFXLENBQUMsR0FBRyxFQUFFO1lBQy9CLElBQUksQ0FBQyxNQUFNLENBQUMsUUFBUSxDQUFDLE9BQU8sQ0FBQyxFQUFFLENBQUM7Z0JBQzlCLE9BQU8sTUFBTSxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsQ0FBQztZQUM5QixDQUFDO1lBQ0QsT0FBTyxPQUFPLENBQUM7UUFDakIsQ0FBQyxDQUFDLEVBQUUsQ0FBQztRQUNMLElBQUksQ0FBQyxRQUFRLEdBQUcsTUFBTSxDQUFDLE1BQU0sQ0FBQyxDQUFDLElBQUksQ0FBQyxRQUFRLEVBQUUsVUFBVSxDQUFDLENBQUMsQ0FBQztJQUM3RCxDQUFDO0lBRU0sU0FBUyxDQUFDLE9BQXdCO1FBQ3ZDLElBQUksQ0FBQyxjQUFjLENBQUMsT0FBTyxDQUFDLENBQUM7UUFDN0IsSUFBSSxDQUFDLFdBQVcsQ0FBQyxPQUFPLENBQUMsQ0FBQztJQUM1QixDQUFDO0NBQ0YifQ==

package/dist_ts/classes.smartexecution.d.ts

@@ -0,0 +1,20 @@
+import { Smartshell, type IExecResultStreaming } from './classes.smartshell.js';
+export interface IDeferred<T> {
+    resolve: (value?: T | PromiseLike<T>) => void;
+    reject: (reason?: any) => void;
+    promise: Promise<T>;
+}
+export declare class SmartExecution {
+    smartshell: Smartshell;
+    currentStreamingExecution: IExecResultStreaming;
+    commandString: string;
+    private isRestartInProgress;
+    private isAnotherRestartRequested;
+    constructor(commandStringArg: string);
+    /**
+     * Schedules a restart. If a restart is currently in progress, any additional calls
+     * to restart will merge into a single additional restart request, which will only execute
+     * once the current restart completes.
+     */
+    restart(): Promise<void>;
+}

package/dist_ts/classes.smartexecution.js

@@ -0,0 +1,42 @@
+import * as plugins from './plugins.js';
+import { Smartshell } from './classes.smartshell.js';
+export class SmartExecution {
+    constructor(commandStringArg) {
+        this.isRestartInProgress = false;
+        this.isAnotherRestartRequested = false;
+        this.commandString = commandStringArg;
+    }
+    /**
+     * Schedules a restart. If a restart is currently in progress, any additional calls
+     * to restart will merge into a single additional restart request, which will only execute
+     * once the current restart completes.
+     */
+    async restart() {
+        if (this.isRestartInProgress) {
+            // If there's already a restart in progress, just mark that another restart was requested
+            this.isAnotherRestartRequested = true;
+            return;
+        }
+        this.isRestartInProgress = true;
+        try {
+            if (!this.smartshell) {
+                this.smartshell = new Smartshell({
+                    executor: 'bash',
+                });
+            }
+            if (this.currentStreamingExecution) {
+                await this.currentStreamingExecution.kill();
+            }
+            this.currentStreamingExecution = await this.smartshell.execStreaming(this.commandString);
+        }
+        finally {
+            this.isRestartInProgress = false;
+        }
+        // If another restart was requested while we were busy, we handle it now
+        if (this.isAnotherRestartRequested) {
+            this.isAnotherRestartRequested = false;
+            await this.restart();
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xhc3Nlcy5zbWFydGV4ZWN1dGlvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL2NsYXNzZXMuc21hcnRleGVjdXRpb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLE9BQU8sTUFBTSxjQUFjLENBQUM7QUFDeEMsT0FBTyxFQUFFLFVBQVUsRUFBNkIsTUFBTSx5QkFBeUIsQ0FBQztBQVFoRixNQUFNLE9BQU8sY0FBYztJQVF6QixZQUFZLGdCQUF3QjtRQUg1Qix3QkFBbUIsR0FBRyxLQUFLLENBQUM7UUFDNUIsOEJBQXlCLEdBQUcsS0FBSyxDQUFDO1FBR3hDLElBQUksQ0FBQyxhQUFhLEdBQUcsZ0JBQWdCLENBQUM7SUFDeEMsQ0FBQztJQUVEOzs7O09BSUc7SUFDSSxLQUFLLENBQUMsT0FBTztRQUNsQixJQUFJLElBQUksQ0FBQyxtQkFBbUIsRUFBRSxDQUFDO1lBQzdCLHlGQUF5RjtZQUN6RixJQUFJLENBQUMseUJBQXlCLEdBQUcsSUFBSSxDQUFDO1lBQ3RDLE9BQU87UUFDVCxDQUFDO1FBRUQsSUFBSSxDQUFDLG1CQUFtQixHQUFHLElBQUksQ0FBQztRQUNoQyxJQUFJLENBQUM7WUFDSCxJQUFJLENBQUMsSUFBSSxDQUFDLFVBQVUsRUFBRSxDQUFDO2dCQUNyQixJQUFJLENBQUMsVUFBVSxHQUFHLElBQUksVUFBVSxDQUFDO29CQUMvQixRQUFRLEVBQUUsTUFBTTtpQkFDakIsQ0FBQyxDQUFDO1lBQ0wsQ0FBQztZQUNELElBQUksSUFBSSxDQUFDLHlCQUF5QixFQUFFLENBQUM7Z0JBQ25DLE1BQU0sSUFBSSxDQUFDLHlCQUF5QixDQUFDLElBQUksRUFBRSxDQUFDO1lBQzlDLENBQUM7WUFDRCxJQUFJLENBQUMseUJBQXlCLEdBQUcsTUFBTSxJQUFJLENBQUMsVUFBVSxDQUFDLGFBQWEsQ0FBQyxJQUFJLENBQUMsYUFBYSxDQUFDLENBQUM7UUFDM0YsQ0FBQztnQkFBUyxDQUFDO1lBQ1QsSUFBSSxDQUFDLG1CQUFtQixHQUFHLEtBQUssQ0FBQztRQUNuQyxDQUFDO1FBRUQsd0VBQXdFO1FBQ3hFLElBQUksSUFBSSxDQUFDLHlCQUF5QixFQUFFLENBQUM7WUFDbkMsSUFBSSxDQUFDLHlCQUF5QixHQUFHLEtBQUssQ0FBQztZQUN2QyxNQUFNLElBQUksQ0FBQyxPQUFPLEVBQUUsQ0FBQztRQUN2QixDQUFDO0lBQ0gsQ0FBQztDQUNGIn0=

package/dist_ts/classes.smartshell.d.ts

@@ -0,0 +1,36 @@
+import * as plugins from './plugins.js';
+import { ShellEnv } from './classes.shellenv.js';
+import type { IShellEnvContructorOptions } from './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: () => Promise<void>;
+    terminate: () => Promise<void>;
+    keyboardInterrupt: () => Promise<void>;
+    customSignal: (signalArg: plugins.smartexit.TProcessSignal) => Promise<void>;
+}
+export declare class Smartshell {
+    shellEnv: ShellEnv;
+    smartexit: plugins.smartexit.SmartExit;
+    constructor(optionsArg: IShellEnvContructorOptions);
+    /**
+     * executes a given command async
+     */
+    private _exec;
+    private _execInteractive;
+    private _execCommand;
+    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/classes.smartshell.js

@@ -0,0 +1,138 @@
+import * as plugins from './plugins.js';
+import { ShellEnv } from './classes.shellenv.js';
+import { ShellLog } from './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) {
+            return await this._execInteractive(options);
+        }
+        return await this._execCommand(options);
+    }
+    async _execInteractive(options) {
+        if (process.env.CI) {
+            return;
+        }
+        const done = plugins.smartpromise.defer();
+        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;
+    }
+    async _execCommand(options) {
+        const done = plugins.smartpromise.defer();
+        const childProcessEnded = plugins.smartpromise.defer();
+        const commandToExecute = this.shellEnv.createEnvExecString(options.commandString);
+        const shellLogInstance = 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) {
+                shellLogInstance.writeToConsole(data);
+            }
+            shellLogInstance.addToBuffer(data);
+        });
+        execChildProcess.stderr.on('data', (data) => {
+            if (!options.silent) {
+                shellLogInstance.writeToConsole(data);
+            }
+            shellLogInstance.addToBuffer(data);
+        });
+        execChildProcess.on('exit', (code, signal) => {
+            this.smartexit.removeProcess(execChildProcess);
+            if (options.strict && code === 1) {
+                done.reject();
+            }
+            const execResult = {
+                exitCode: code,
+                stdout: shellLogInstance.logStore.toString(),
+            };
+            if (!options.streaming) {
+                done.resolve(execResult);
+            }
+            childProcessEnded.resolve(execResult);
+        });
+        if (options.streaming) {
+            done.resolve({
+                childProcess: execChildProcess,
+                finalPromise: childProcessEnded.promise,
+                kill: async () => {
+                    console.log(`running tree kill with SIGKILL on process ${execChildProcess.pid}`);
+                    await plugins.smartexit.SmartExit.killTreeByPid(execChildProcess.pid, 'SIGKILL');
+                },
+                terminate: async () => {
+                    console.log(`running tree kill with SIGTERM on process ${execChildProcess.pid}`);
+                    await plugins.smartexit.SmartExit.killTreeByPid(execChildProcess.pid, 'SIGTERM');
+                },
+                keyboardInterrupt: async () => {
+                    console.log(`running tree kill with SIGINT on process ${execChildProcess.pid}`);
+                    await plugins.smartexit.SmartExit.killTreeByPid(execChildProcess.pid, 'SIGINT');
+                },
+                customSignal: async (signalArg) => {
+                    console.log(`running tree kill with custom signal ${signalArg} on process ${execChildProcess.pid}`);
+                    await plugins.smartexit.SmartExit.killTreeByPid(execChildProcess.pid, signalArg);
+                },
+            });
+        }
+        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/index.d.ts

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

package/dist_ts/index.js

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

package/dist_ts/plugins.d.ts

@@ -0,0 +1,5 @@
+import * as smartdelay from '@push.rocks/smartdelay';
+import * as smartexit from '@push.rocks/smartexit';
+import * as smartpromise from '@push.rocks/smartpromise';
+import which from 'which';
+export { smartdelay, smartexit, smartpromise, which };

package/dist_ts/plugins.js

@@ -0,0 +1,6 @@
+import * as smartdelay from '@push.rocks/smartdelay';
+import * as smartexit from '@push.rocks/smartexit';
+import * as smartpromise from '@push.rocks/smartpromise';
+import which from 'which';
+export { smartdelay, smartexit, smartpromise, which };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3BsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLFVBQVUsTUFBTSx3QkFBd0IsQ0FBQztBQUNyRCxPQUFPLEtBQUssU0FBUyxNQUFNLHVCQUF1QixDQUFDO0FBQ25ELE9BQU8sS0FBSyxZQUFZLE1BQU0sMEJBQTBCLENBQUM7QUFDekQsT0FBTyxLQUFLLE1BQU0sT0FBTyxDQUFDO0FBRTFCLE9BQU8sRUFBRSxVQUFVLEVBQUUsU0FBUyxFQUFFLFlBQVksRUFBRSxLQUFLLEVBQUUsQ0FBQyJ9

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@push.rocks/smartshell",
   "private": false,
-  "version": "3.0.6",
+  "version": "3.2.0",
   "description": "A library for executing shell commands using promises.",
   "main": "dist_ts/index.js",
   "typings": "dist_ts/index.d.ts",
@@ -28,11 +28,11 @@
   },
   "homepage": "https://code.foss.global/push.rocks/smartshell",
   "devDependencies": {
-    "@git.zone/tsbuild": "^2.1.84",
-    "@git.zone/tsrun": "^1.2.49",
+    "@git.zone/tsbuild": "^2.2.0",
+    "@git.zone/tsrun": "^1.3.3",
     "@git.zone/tstest": "^1.0.90",
-    "@push.rocks/tapbundle": "^5.0.24",
-    "@types/node": "^22.5.5"
+    "@push.rocks/tapbundle": "^5.5.3",
+    "@types/node": "^22.10.1"
   },
   "dependencies": {
     "@push.rocks/smartdelay": "^3.0.1",
@@ -40,7 +40,7 @@
     "@push.rocks/smartpromise": "^4.0.4",
     "@types/which": "^3.0.4",
     "tree-kill": "^1.2.2",
-    "which": "^4.0.0"
+    "which": "^5.0.0"
   },
   "files": [
     "ts/**/*",
@@ -59,7 +59,7 @@
   ],
   "scripts": {
     "test": "(tstest test/)",
-    "build": "(tsbuild --web)",
+    "build": "(tsbuild tsfolders --web)",
     "buildDocs": "tsdoc"
   }
 }

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@push.rocks/smartshell',
-  version: '3.0.6',
+  version: '3.2.0',
   description: 'A library for executing shell commands using promises.'
 }

package/ts/{smartshell.classes.shelllog.ts → classes.shelllog.ts}

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

package/ts/classes.smartexecution.ts

@@ -0,0 +1,55 @@
+import * as plugins from './plugins.js';
+import { Smartshell, type IExecResultStreaming } from './classes.smartshell.js';
+
+export interface IDeferred<T> {
+  resolve: (value?: T | PromiseLike<T>) => void;
+  reject: (reason?: any) => void;
+  promise: Promise<T>;
+}
+
+export class SmartExecution {
+  public smartshell: Smartshell;
+  public currentStreamingExecution: IExecResultStreaming;
+  public commandString: string;
+
+  private isRestartInProgress = false;
+  private isAnotherRestartRequested = false;
+
+  constructor(commandStringArg: string) {
+    this.commandString = commandStringArg;
+  }
+
+  /**
+   * Schedules a restart. If a restart is currently in progress, any additional calls
+   * to restart will merge into a single additional restart request, which will only execute
+   * once the current restart completes.
+   */
+  public async restart(): Promise<void> {
+    if (this.isRestartInProgress) {
+      // If there's already a restart in progress, just mark that another restart was requested
+      this.isAnotherRestartRequested = true;
+      return;
+    }
+
+    this.isRestartInProgress = true;
+    try {
+      if (!this.smartshell) {
+        this.smartshell = new Smartshell({
+          executor: 'bash',
+        });
+      }
+      if (this.currentStreamingExecution) {
+        await this.currentStreamingExecution.kill();
+      }
+      this.currentStreamingExecution = await this.smartshell.execStreaming(this.commandString);
+    } finally {
+      this.isRestartInProgress = false;
+    }
+
+    // If another restart was requested while we were busy, we handle it now
+    if (this.isAnotherRestartRequested) {
+      this.isAnotherRestartRequested = false;
+      await this.restart();
+    }
+  }
+}

package/ts/{smartshell.classes.smartshell.ts → classes.smartshell.ts}

@@ -1,7 +1,7 @@
-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 plugins from './plugins.js';
+import { ShellEnv } from './classes.shellenv.js';
+import type { IShellEnvContructorOptions, TExecutor } from './classes.shellenv.js';
+import { ShellLog } from './classes.shelllog.js';
 
 import * as cp from 'child_process';
 

package/ts/index.ts

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