@push.rocks/smartshell 3.0.5 → 3.1.0

package/dist_ts/00_commitinfo_data.d.ts

@@ -1,5 +1,5 @@
 /**
- * autocreated commitinfo by @pushrocks/commitinfo
+ * autocreated commitinfo by @push.rocks/commitinfo
  */
 export declare const commitinfo: {
     name: string;

package/dist_ts/00_commitinfo_data.js

@@ -1,9 +1,9 @@
 /**
- * autocreated commitinfo by @pushrocks/commitinfo
+ * autocreated commitinfo by @push.rocks/commitinfo
  */
 export const commitinfo = {
     name: '@push.rocks/smartshell',
-    version: '3.0.5',
+    version: '3.1.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,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

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,8 @@
+import { Smartshell, type IExecResultStreaming } from './classes.smartshell.js';
+export declare class SmartExecution {
+    smartshell: Smartshell;
+    currentStreamingExecution: IExecResultStreaming;
+    commandString: string;
+    constructor(commandStringArg: string);
+    restart(): Promise<void>;
+}

package/dist_ts/classes.smartexecution.js

@@ -0,0 +1,19 @@
+import * as plugins from './plugins.js';
+import { Smartshell } from './classes.smartshell.js';
+export class SmartExecution {
+    constructor(commandStringArg) {
+        this.commandString = commandStringArg;
+    }
+    async restart() {
+        if (!this.smartshell) {
+            this.smartshell = new Smartshell({
+                executor: 'bash',
+            });
+        }
+        if (this.currentStreamingExecution) {
+            await this.currentStreamingExecution.kill();
+        }
+        this.currentStreamingExecution = await this.smartshell.execStreaming(this.commandString);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xhc3Nlcy5zbWFydGV4ZWN1dGlvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL2NsYXNzZXMuc21hcnRleGVjdXRpb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLE9BQU8sTUFBTSxjQUFjLENBQUE7QUFDdkMsT0FBTyxFQUFFLFVBQVUsRUFBNkIsTUFBTSx5QkFBeUIsQ0FBQztBQUVoRixNQUFNLE9BQU8sY0FBYztJQUt6QixZQUFZLGdCQUF3QjtRQUNsQyxJQUFJLENBQUMsYUFBYSxHQUFHLGdCQUFnQixDQUFDO0lBQ3hDLENBQUM7SUFFTSxLQUFLLENBQUMsT0FBTztRQUNsQixJQUFJLENBQUMsSUFBSSxDQUFDLFVBQVUsRUFBRSxDQUFDO1lBQ3JCLElBQUksQ0FBQyxVQUFVLEdBQUcsSUFBSSxVQUFVLENBQUM7Z0JBQy9CLFFBQVEsRUFBRSxNQUFNO2FBQ2pCLENBQUMsQ0FBQztRQUNMLENBQUM7UUFDRCxJQUFJLElBQUksQ0FBQyx5QkFBeUIsRUFBRSxDQUFDO1lBQ25DLE1BQU0sSUFBSSxDQUFDLHlCQUF5QixDQUFDLElBQUksRUFBRSxDQUFDO1FBQzlDLENBQUM7UUFDRCxJQUFJLENBQUMseUJBQXlCLEdBQUcsTUFBTSxJQUFJLENBQUMsVUFBVSxDQUFDLGFBQWEsQ0FBQyxJQUFJLENBQUMsYUFBYSxDQUFDLENBQUM7SUFDM0YsQ0FBQztDQUNGIn0=

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/dist_ts/smartshell.classes.shelllog.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" resolution-mode="require"/>
 /**
  * a log handler for spawned logs
  * making sure the process doesn't run out of memory

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

@@ -1,4 +1,3 @@
-/// <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';
@@ -23,6 +22,8 @@ export declare class Smartshell {
      * 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>;

package/dist_ts/smartshell.classes.smartshell.js

@@ -12,30 +12,33 @@ export class Smartshell {
      */
     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 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();
-        let commandToExecute = options.commandString;
-        commandToExecute = this.shellEnv.createEnvExecString(options.commandString);
-        const spawnlogInstance = new ShellLog();
+        const commandToExecute = this.shellEnv.createEnvExecString(options.commandString);
+        const shellLogInstance = new ShellLog();
         const execChildProcess = cp.spawn(commandToExecute, [], {
             shell: true,
             cwd: process.cwd(),
@@ -45,15 +48,15 @@ export class Smartshell {
         this.smartexit.addProcess(execChildProcess);
         execChildProcess.stdout.on('data', (data) => {
             if (!options.silent) {
-                spawnlogInstance.writeToConsole(data);
+                shellLogInstance.writeToConsole(data);
             }
-            spawnlogInstance.addToBuffer(data);
+            shellLogInstance.addToBuffer(data);
         });
         execChildProcess.stderr.on('data', (data) => {
             if (!options.silent) {
-                spawnlogInstance.writeToConsole(data);
+                shellLogInstance.writeToConsole(data);
             }
-            spawnlogInstance.addToBuffer(data);
+            shellLogInstance.addToBuffer(data);
         });
         execChildProcess.on('exit', (code, signal) => {
             this.smartexit.removeProcess(execChildProcess);
@@ -62,7 +65,7 @@ export class Smartshell {
             }
             const execResult = {
                 exitCode: code,
-                stdout: spawnlogInstance.logStore.toString(),
+                stdout: shellLogInstance.logStore.toString(),
             };
             if (!options.streaming) {
                 done.resolve(execResult);
@@ -132,4 +135,4 @@ export class Smartshell {
         return this.execAndWaitForLine(commandString, regexArg, true);
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@push.rocks/smartshell",
   "private": false,
-  "version": "3.0.5",
+  "version": "3.1.0",
   "description": "A library for executing shell commands using promises.",
   "main": "dist_ts/index.js",
   "typings": "dist_ts/index.d.ts",
   "type": "module",
   "repository": {
     "type": "git",
-    "url": "git+ssh://git@gitlab.com/pushrocks/smartshell.git"
+    "url": "https://code.foss.global/push.rocks/smartshell.git"
   },
   "keywords": [
     "shell commands",
@@ -26,21 +26,21 @@
   "bugs": {
     "url": "https://gitlab.com/pushrocks/smartshell/issues"
   },
-  "homepage": "https://gitlab.com/pushrocks/smartshell#README",
+  "homepage": "https://code.foss.global/push.rocks/smartshell",
   "devDependencies": {
-    "@git.zone/tsbuild": "^2.1.66",
-    "@git.zone/tsrun": "^1.2.44",
-    "@git.zone/tstest": "^1.0.77",
-    "@push.rocks/tapbundle": "^5.0.23",
-    "@types/node": "^20.12.7"
+    "@git.zone/tsbuild": "^2.2.0",
+    "@git.zone/tsrun": "^1.3.3",
+    "@git.zone/tstest": "^1.0.90",
+    "@push.rocks/tapbundle": "^5.5.3",
+    "@types/node": "^22.10.1"
   },
   "dependencies": {
     "@push.rocks/smartdelay": "^3.0.1",
     "@push.rocks/smartexit": "^1.0.23",
-    "@push.rocks/smartpromise": "^4.0.2",
-    "@types/which": "^3.0.3",
+    "@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

@@ -1,8 +1,8 @@
 /**
- * autocreated commitinfo by @pushrocks/commitinfo
+ * autocreated commitinfo by @push.rocks/commitinfo
  */
 export const commitinfo = {
   name: '@push.rocks/smartshell',
-  version: '3.0.5',
+  version: '3.1.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,24 @@
+import * as plugins from './plugins.js'
+import { Smartshell, type IExecResultStreaming } from './classes.smartshell.js';
+
+export class SmartExecution {
+  public smartshell: Smartshell;
+  public currentStreamingExecution: IExecResultStreaming;
+  public commandString: string;
+
+  constructor(commandStringArg: string) {
+    this.commandString = commandStringArg;
+  }
+
+  public async restart() {
+    if (!this.smartshell) {
+      this.smartshell = new Smartshell({
+        executor: 'bash',
+      });
+    }
+    if (this.currentStreamingExecution) {
+      await this.currentStreamingExecution.kill();
+    }
+    this.currentStreamingExecution = await this.smartshell.execStreaming(this.commandString);
+  }
+}

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';
 
@@ -39,39 +39,51 @@ export class Smartshell {
     interactive?: boolean;
   }): Promise<IExecResult | IExecResultStreaming | void> {
     if (options.interactive) {
-      if (process.env.CI) {
-        return;
-      }
+      return await this._execInteractive(options);
+    }
 
-      const done = plugins.smartpromise.defer();
-      
-      // Notice that stdio is set to 'inherit'
-      const shell = cp.spawn(options.commandString, {
-        stdio: 'inherit',
-        shell: true,
-        detached: true
-      });
+    return await this._execCommand(options);
+  }
 
-      this.smartexit.addProcess(shell);
+  private async _execInteractive(options: {
+    commandString: string;
+    interactive?: boolean;
+  }): Promise<void> {
+    if (process.env.CI) {
+      return;
+    }
 
-      shell.on('close', (code) => {
-        console.log(`interactive shell terminated with code ${code}`);
-        this.smartexit.removeProcess(shell);
-        done.resolve();
-      });
+    const done = plugins.smartpromise.defer();
 
-      await done.promise;
+    const shell = cp.spawn(options.commandString, {
+      stdio: 'inherit',
+      shell: true,
+      detached: true
+    });
 
-      return;
-    }
+    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;
+  }
 
+  private async _execCommand(options: {
+    commandString: string;
+    silent?: boolean;
+    strict?: boolean;
+    streaming?: boolean;
+  }): Promise<IExecResult | IExecResultStreaming> {
     const done = plugins.smartpromise.defer<IExecResult | IExecResultStreaming>();
     const childProcessEnded = plugins.smartpromise.defer<IExecResult>();
 
-    let commandToExecute = options.commandString;
-    commandToExecute = this.shellEnv.createEnvExecString(options.commandString);
+    const commandToExecute = this.shellEnv.createEnvExecString(options.commandString);
 
-    const spawnlogInstance = new ShellLog();
+    const shellLogInstance = new ShellLog();
     const execChildProcess = cp.spawn(commandToExecute, [], {
       shell: true,
       cwd: process.cwd(),
@@ -83,16 +95,16 @@ export class Smartshell {
 
     execChildProcess.stdout.on('data', (data) => {
       if (!options.silent) {
-        spawnlogInstance.writeToConsole(data);
+        shellLogInstance.writeToConsole(data);
       }
-      spawnlogInstance.addToBuffer(data);
+      shellLogInstance.addToBuffer(data);
     });
 
     execChildProcess.stderr.on('data', (data) => {
       if (!options.silent) {
-        spawnlogInstance.writeToConsole(data);
+        shellLogInstance.writeToConsole(data);
       }
-      spawnlogInstance.addToBuffer(data);
+      shellLogInstance.addToBuffer(data);
     });
 
     execChildProcess.on('exit', (code, signal) => {
@@ -103,7 +115,7 @@ export class Smartshell {
 
       const execResult = {
         exitCode: code,
-        stdout: spawnlogInstance.logStore.toString(),
+        stdout: shellLogInstance.logStore.toString(),
       };
 
       if (!options.streaming) {
@@ -191,4 +203,4 @@ export class Smartshell {
   public async execAndWaitForLineSilent(commandString: string, regexArg: RegExp) {
     return this.execAndWaitForLine(commandString, regexArg, true);
   }
-}
+}

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';