@positronic/shell 0.0.1

package/dist/src/index.js

@@ -0,0 +1,3 @@
+import { LocalShell } from './local-shell';
+import { SSH2Shell } from './ssh2-shell';
+export { LocalShell, SSH2Shell };

package/dist/src/local-shell.js

@@ -0,0 +1,299 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+function _object_without_properties(source, excluded) {
+    if (source == null) return {};
+    var target = _object_without_properties_loose(source, excluded);
+    var key, i;
+    if (Object.getOwnPropertySymbols) {
+        var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+        for(i = 0; i < sourceSymbolKeys.length; i++){
+            key = sourceSymbolKeys[i];
+            if (excluded.indexOf(key) >= 0) continue;
+            if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+            target[key] = source[key];
+        }
+    }
+    return target;
+}
+function _object_without_properties_loose(source, excluded) {
+    if (source == null) return {};
+    var target = {};
+    var sourceKeys = Object.keys(source);
+    var key, i;
+    for(i = 0; i < sourceKeys.length; i++){
+        key = sourceKeys[i];
+        if (excluded.indexOf(key) >= 0) continue;
+        target[key] = source[key];
+    }
+    return target;
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, g, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    };
+    return g = {
+        next: verb(0),
+        "throw": verb(1),
+        "return": verb(2)
+    }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(_)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+import { spawn } from 'child_process';
+import { Readable } from 'stream';
+export var LocalShell = /*#__PURE__*/ function() {
+    "use strict";
+    function LocalShell() {
+        var config = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+        _class_call_check(this, LocalShell);
+        _define_property(this, "config", void 0);
+        this.config = config;
+    }
+    _create_class(LocalShell, [
+        {
+            key: "execCommand",
+            value: function execCommand(givenCommand) {
+                var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+                var _this = this;
+                return _async_to_generator(function() {
+                    return _ts_generator(this, function(_state) {
+                        return [
+                            2,
+                            new Promise(function(resolve, reject) {
+                                var _options_cwd = options.cwd, cwd = _options_cwd === void 0 ? _this.config.cwd || process.cwd() : _options_cwd, stdin = options.stdin, _options_encoding = options.encoding, encoding = _options_encoding === void 0 ? 'utf8' : _options_encoding, _options_noTrim = options.noTrim, noTrim = _options_noTrim === void 0 ? false : _options_noTrim, onStdout = options.onStdout, onStderr = options.onStderr, _options_env = options.env, env = _options_env === void 0 ? _this.config.env : _options_env, timeout = options.timeout, _options_shell = options.shell, shell = _options_shell === void 0 ? _this.config.shell || 'bash' : _options_shell;
+                                var childProcess = spawn(shell, [
+                                    '-c',
+                                    givenCommand
+                                ], {
+                                    cwd: cwd,
+                                    env: env,
+                                    timeout: timeout
+                                });
+                                var stdout = '';
+                                var stderr = '';
+                                childProcess.stdout.on('data', function(data) {
+                                    var chunk = data.toString(encoding);
+                                    stdout += chunk;
+                                    onStdout === null || onStdout === void 0 ? void 0 : onStdout(data);
+                                });
+                                childProcess.stderr.on('data', function(data) {
+                                    var chunk = data.toString(encoding);
+                                    stderr += chunk;
+                                    onStderr === null || onStderr === void 0 ? void 0 : onStderr(data);
+                                });
+                                if (stdin) {
+                                    if (typeof stdin === 'string') {
+                                        childProcess.stdin.write(stdin);
+                                        childProcess.stdin.end();
+                                    } else if (_instanceof(stdin, Readable)) {
+                                        stdin.pipe(childProcess.stdin);
+                                    }
+                                }
+                                childProcess.on('close', function(code, signal) {
+                                    if (!noTrim) {
+                                        stdout = stdout.trim();
+                                        stderr = stderr.trim();
+                                    }
+                                    resolve({
+                                        stdout: stdout,
+                                        stderr: stderr,
+                                        code: code,
+                                        signal: signal
+                                    });
+                                });
+                                childProcess.on('error', function(error) {
+                                    reject(error);
+                                });
+                            })
+                        ];
+                    });
+                })();
+            }
+        },
+        {
+            key: "exec",
+            value: function exec(command, parameters) {
+                var options = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
+                var _this = this;
+                return _async_to_generator(function() {
+                    var _options_stream, stream, execOptions, fullCommand, result;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                _options_stream = options.stream, stream = _options_stream === void 0 ? 'stdout' : _options_stream, execOptions = _object_without_properties(options, [
+                                    "stream"
+                                ]);
+                                fullCommand = "".concat(command, " ").concat(parameters.join(' '));
+                                return [
+                                    4,
+                                    _this.execCommand(fullCommand, execOptions)
+                                ];
+                            case 1:
+                                result = _state.sent();
+                                if (stream === 'both') {
+                                    return [
+                                        2,
+                                        result
+                                    ];
+                                }
+                                return [
+                                    2,
+                                    stream === 'stdout' ? result.stdout : result.stderr
+                                ];
+                        }
+                    });
+                })();
+            }
+        }
+    ]);
+    return LocalShell;
+}();

package/dist/src/ssh2-shell.js

@@ -0,0 +1,368 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function _object_without_properties(source, excluded) {
+    if (source == null) return {};
+    var target = _object_without_properties_loose(source, excluded);
+    var key, i;
+    if (Object.getOwnPropertySymbols) {
+        var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+        for(i = 0; i < sourceSymbolKeys.length; i++){
+            key = sourceSymbolKeys[i];
+            if (excluded.indexOf(key) >= 0) continue;
+            if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+            target[key] = source[key];
+        }
+    }
+    return target;
+}
+function _object_without_properties_loose(source, excluded) {
+    if (source == null) return {};
+    var target = {};
+    var sourceKeys = Object.keys(source);
+    var key, i;
+    for(i = 0; i < sourceKeys.length; i++){
+        key = sourceKeys[i];
+        if (excluded.indexOf(key) >= 0) continue;
+        target[key] = source[key];
+    }
+    return target;
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, g, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    };
+    return g = {
+        next: verb(0),
+        "throw": verb(1),
+        "return": verb(2)
+    }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(_)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+import { Client } from 'ssh2';
+export var SSH2Shell = /*#__PURE__*/ function() {
+    "use strict";
+    function SSH2Shell(config) {
+        _class_call_check(this, SSH2Shell);
+        _define_property(this, "config", void 0);
+        _define_property(this, "client", void 0);
+        _define_property(this, "defaultCwd", void 0);
+        this.config = config;
+        this.client = new Client();
+        this.defaultCwd = config.cwd;
+    }
+    _create_class(SSH2Shell, [
+        {
+            key: "connect",
+            value: function connect() {
+                var _this = this;
+                return _async_to_generator(function() {
+                    return _ts_generator(this, function(_state) {
+                        return [
+                            2,
+                            new Promise(function(resolve, reject) {
+                                _this.client.on('ready', function() {
+                                    resolve();
+                                });
+                                _this.client.on('error', function(err) {
+                                    reject(err);
+                                });
+                                _this.client.connect(_this.config);
+                            })
+                        ];
+                    });
+                })();
+            }
+        },
+        {
+            key: "execCommand",
+            value: function execCommand(givenCommand) {
+                var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+                var _this = this;
+                return _async_to_generator(function() {
+                    return _ts_generator(this, function(_state) {
+                        return [
+                            2,
+                            new Promise(function(resolve, reject) {
+                                var env = _object_spread({}, _this.config.env, options.env);
+                                var shell = _this.config.shell || options.shell || null;
+                                var shellCommand = shell ? "".concat(shell, ' -c "').concat(givenCommand, '"') : givenCommand;
+                                var cwd = options.cwd || _this.defaultCwd;
+                                if (cwd) {
+                                    // Prepend cd command if cwd is specified
+                                    var fullCommand = "cd ".concat(cwd, " && ").concat(shellCommand);
+                                    _this.client.exec(fullCommand, {
+                                        env: env
+                                    }, function(err, stream) {
+                                        if (err) {
+                                            reject(err);
+                                            return;
+                                        }
+                                        var _options_noTrim = options.noTrim, noTrim = _options_noTrim === void 0 ? false : _options_noTrim;
+                                        var stdout = [];
+                                        var stderr = [];
+                                        stream.on('data', function(data) {
+                                            stdout.push(data.toString());
+                                        });
+                                        stream.stderr.on('data', function(data) {
+                                            stderr.push(data.toString());
+                                        });
+                                        stream.on('close', function(code, signal) {
+                                            var response = {
+                                                stdout: noTrim ? stdout.join('') : stdout.join('').trim(),
+                                                stderr: noTrim ? stderr.join('') : stderr.join('').trim(),
+                                                code: code,
+                                                signal: signal
+                                            };
+                                            resolve(response);
+                                        });
+                                        stream.on('error', function(err) {
+                                            reject(err);
+                                        });
+                                    });
+                                } else {
+                                    _this.client.exec(shellCommand, {
+                                        env: env
+                                    }, function(err, stream) {
+                                        if (err) {
+                                            reject(err);
+                                            return;
+                                        }
+                                        var _options_noTrim = options.noTrim, noTrim = _options_noTrim === void 0 ? false : _options_noTrim;
+                                        var stdout = [];
+                                        var stderr = [];
+                                        stream.on('data', function(data) {
+                                            stdout.push(data.toString());
+                                        });
+                                        stream.stderr.on('data', function(data) {
+                                            stderr.push(data.toString());
+                                        });
+                                        stream.on('close', function(code, signal) {
+                                            var response = {
+                                                stdout: noTrim ? stdout.join('') : stdout.join('').trim(),
+                                                stderr: noTrim ? stderr.join('') : stderr.join('').trim(),
+                                                code: code,
+                                                signal: signal
+                                            };
+                                            resolve(response);
+                                        });
+                                        stream.on('error', function(err) {
+                                            reject(err);
+                                        });
+                                    });
+                                }
+                            })
+                        ];
+                    });
+                })();
+            }
+        },
+        {
+            key: "exec",
+            value: function exec(command, parameters) {
+                var options = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
+                var _this = this;
+                return _async_to_generator(function() {
+                    var _options_stream, stream, execOptions, fullCommand, result;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                _options_stream = options.stream, stream = _options_stream === void 0 ? 'stdout' : _options_stream, execOptions = _object_without_properties(options, [
+                                    "stream"
+                                ]);
+                                fullCommand = "".concat(command, " ").concat(parameters.join(' '));
+                                return [
+                                    4,
+                                    _this.execCommand(fullCommand, execOptions)
+                                ];
+                            case 1:
+                                result = _state.sent();
+                                if (stream === 'both') {
+                                    return [
+                                        2,
+                                        result
+                                    ];
+                                }
+                                return [
+                                    2,
+                                    stream === 'stdout' ? result.stdout : result.stderr
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "disconnect",
+            value: function disconnect() {
+                var _this = this;
+                return _async_to_generator(function() {
+                    return _ts_generator(this, function(_state) {
+                        _this.client.end();
+                        return [
+                            2
+                        ];
+                    });
+                })();
+            }
+        }
+    ]);
+    return SSH2Shell;
+}();

package/dist/src/types.js

@@ -0,0 +1 @@
+export { };

package/dist/types/index.d.ts

@@ -0,0 +1,4 @@
+import { LocalShell } from './local-shell';
+import { SSH2Shell } from './ssh2-shell';
+export { LocalShell, SSH2Shell };
+//# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAEzC,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,CAAC"}

package/dist/types/local-shell.d.ts

@@ -0,0 +1,14 @@
+import type { Shell, ExecCommandOptions, ExecCommandResponse } from './types';
+interface LocalShellOptions {
+    cwd?: string;
+    shell?: string;
+    env?: NodeJS.ProcessEnv;
+}
+export declare class LocalShell implements Shell {
+    private config;
+    constructor(config?: LocalShellOptions);
+    execCommand(givenCommand: string, options?: ExecCommandOptions): Promise<ExecCommandResponse>;
+    exec(command: string, parameters: string[], options?: ExecCommandOptions): Promise<string | ExecCommandResponse>;
+}
+export {};
+//# sourceMappingURL=local-shell.d.ts.map

package/dist/types/local-shell.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"local-shell.d.ts","sourceRoot":"","sources":["../../src/local-shell.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,KAAK,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAE9E,UAAU,iBAAiB;IACzB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;CACzB;AAED,qBAAa,UAAW,YAAW,KAAK;IAC1B,OAAO,CAAC,MAAM;gBAAN,MAAM,GAAE,iBAAsB;IAE5C,WAAW,CAAC,YAAY,EAAE,MAAM,EAAE,OAAO,GAAE,kBAAuB,GAAG,OAAO,CAAC,mBAAmB,CAAC;IA+DjG,IAAI,CACR,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,MAAM,EAAE,EACpB,OAAO,GAAE,kBAAuB,GAC/B,OAAO,CAAC,MAAM,GAAG,mBAAmB,CAAC;CAWzC"}

package/dist/types/ssh2-shell.d.ts

@@ -0,0 +1,21 @@
+import type { Shell, ExecCommandOptions, ExecCommandResponse } from './types';
+import type { ConnectConfig } from 'ssh2';
+interface SSH2ShellOptions extends ConnectConfig {
+    env?: NodeJS.ProcessEnv;
+    timeout?: number;
+    shell?: 'bash' | 'sh' | 'zsh';
+    noTrim?: boolean;
+    cwd?: string;
+}
+export declare class SSH2Shell implements Shell {
+    private config;
+    private client;
+    private defaultCwd?;
+    constructor(config: SSH2ShellOptions);
+    connect(): Promise<void>;
+    execCommand(givenCommand: string, options?: ExecCommandOptions): Promise<ExecCommandResponse>;
+    exec(command: string, parameters: string[], options?: ExecCommandOptions): Promise<string | ExecCommandResponse>;
+    disconnect(): Promise<void>;
+}
+export {};
+//# sourceMappingURL=ssh2-shell.d.ts.map

package/dist/types/ssh2-shell.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ssh2-shell.d.ts","sourceRoot":"","sources":["../../src/ssh2-shell.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAC9E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,MAAM,CAAC;AAE1C,UAAU,gBAAiB,SAAQ,aAAa;IAC9C,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;IACxB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,KAAK,CAAC;IAC9B,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAED,qBAAa,SAAU,YAAW,KAAK;IAIzB,OAAO,CAAC,MAAM;IAH1B,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,UAAU,CAAC,CAAS;gBAER,MAAM,EAAE,gBAAgB;IAKtC,OAAO;IAcP,WAAW,CACf,YAAY,EAAE,MAAM,EACpB,OAAO,GAAE,kBAAuB;IAsF5B,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,EAAE,OAAO,GAAE,kBAAuB;IAY5E,UAAU;CAGjB"}

package/dist/types/types.d.ts

@@ -0,0 +1,24 @@
+import { Readable } from 'stream';
+export interface ExecCommandOptions {
+    cwd?: string;
+    stdin?: string | Readable;
+    env?: Record<string, string>;
+    timeout?: number;
+    shell?: 'sh' | 'bash' | 'zsh' | 'powershell';
+    encoding?: BufferEncoding;
+    noTrim?: boolean;
+    onStdout?: (chunk: Buffer) => void;
+    onStderr?: (chunk: Buffer) => void;
+    stream?: 'stdout' | 'stderr' | 'both';
+}
+export interface ExecCommandResponse {
+    stdout: string;
+    stderr: string;
+    code: number | null;
+    signal: string | null;
+}
+export interface Shell {
+    execCommand(givenCommand: string, options?: ExecCommandOptions): Promise<ExecCommandResponse>;
+    exec(command: string, parameters: string[], options?: ExecCommandOptions): Promise<string | ExecCommandResponse>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAC;AAElC,MAAM,WAAW,kBAAkB;IACjC,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,GAAG,QAAQ,CAAC;IAC1B,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,IAAI,GAAG,MAAM,GAAG,KAAK,GAAG,YAAY,CAAC;IAC7C,QAAQ,CAAC,EAAE,cAAc,CAAC;IAC1B,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IACnC,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IACnC,MAAM,CAAC,EAAE,QAAQ,GAAG,QAAQ,GAAG,MAAM,CAAC;CACvC;AAED,MAAM,WAAW,mBAAmB;IAClC,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;CACvB;AAED,MAAM,WAAW,KAAK;IACpB,WAAW,CAAC,YAAY,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,kBAAkB,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAAC;IAC9F,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,EAAE,OAAO,CAAC,EAAE,kBAAkB,GAAG,OAAO,CAAC,MAAM,GAAG,mBAAmB,CAAC,CAAC;CAClH"}

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@positronic/shell",
+  "version": "0.0.1",
+  "description": "Shell implementations for Positronic",
+  "type": "module",
+  "main": "dist/src/index.js",
+  "types": "dist/types/index.ts",
+  "scripts": {
+    "tsc": "tsc --project tsconfig.json",
+    "swc": "swc src -d dist",
+    "build": "npm run tsc && npm run swc",
+    "clean": "rm -rf tsconfig.tsbuildinfo dist"
+  },
+  "dependencies": {
+    "ssh2": "^1.14.0"
+  },
+  "devDependencies": {
+    "@types/ssh2": "^1.15.4"
+  }
+}

package/src/index.ts

@@ -0,0 +1,4 @@
+import { LocalShell } from './local-shell';
+import { SSH2Shell } from './ssh2-shell';
+
+export { LocalShell, SSH2Shell };

package/src/local-shell.ts

@@ -0,0 +1,93 @@
+import { spawn } from 'child_process';
+import { Readable } from 'stream';
+
+import type { Shell, ExecCommandOptions, ExecCommandResponse } from './types';
+
+interface LocalShellOptions {
+  cwd?: string;
+  shell?: string;
+  env?: NodeJS.ProcessEnv;
+}
+
+export class LocalShell implements Shell {
+  constructor(private config: LocalShellOptions = {}) {}
+
+  async execCommand(givenCommand: string, options: ExecCommandOptions = {}): Promise<ExecCommandResponse> {
+    return new Promise((resolve, reject) => {
+      const {
+        cwd = this.config.cwd || process.cwd(),
+        stdin,
+        encoding = 'utf8',
+        noTrim = false,
+        onStdout,
+        onStderr,
+        env = this.config.env,
+        timeout,
+        shell = this.config.shell || 'bash'
+      } = options;
+
+      const childProcess = spawn(shell, ['-c', givenCommand], {
+        cwd,
+        env,
+        timeout,
+      });
+
+      let stdout = '';
+      let stderr = '';
+
+      childProcess.stdout.on('data', (data: Buffer) => {
+        const chunk = data.toString(encoding);
+        stdout += chunk;
+        onStdout?.(data);
+      });
+
+      childProcess.stderr.on('data', (data: Buffer) => {
+        const chunk = data.toString(encoding);
+        stderr += chunk;
+        onStderr?.(data);
+      });
+
+      if (stdin) {
+        if (typeof stdin === 'string') {
+          childProcess.stdin.write(stdin);
+          childProcess.stdin.end();
+        } else if (stdin instanceof Readable) {
+          stdin.pipe(childProcess.stdin);
+        }
+      }
+
+      childProcess.on('close', (code, signal) => {
+        if (!noTrim) {
+          stdout = stdout.trim();
+          stderr = stderr.trim();
+        }
+        resolve({
+          stdout,
+          stderr,
+          code,
+          signal,
+        });
+      });
+
+      childProcess.on('error', (error) => {
+        reject(error);
+      });
+    });
+  }
+
+  async exec(
+    command: string,
+    parameters: string[],
+    options: ExecCommandOptions = {}
+  ): Promise<string | ExecCommandResponse> {
+    const { stream = 'stdout', ...execOptions } = options;
+    const fullCommand = `${command} ${parameters.join(' ')}`;
+    const result = await this.execCommand(fullCommand, execOptions);
+
+    if (stream === 'both') {
+      return result;
+    }
+
+    return stream === 'stdout' ? result.stdout : result.stderr;
+  }
+}

package/src/ssh2-shell.ts

@@ -0,0 +1,139 @@
+import { Client, ClientChannel } from 'ssh2';
+import type { Shell, ExecCommandOptions, ExecCommandResponse } from './types';
+import type { ConnectConfig } from 'ssh2';
+
+interface SSH2ShellOptions extends ConnectConfig {
+  env?: NodeJS.ProcessEnv;
+  timeout?: number;
+  shell?: 'bash' | 'sh' | 'zsh';
+  noTrim?: boolean;
+  cwd?: string;
+}
+
+export class SSH2Shell implements Shell {
+  private client: Client;
+  private defaultCwd?: string;
+
+  constructor(private config: SSH2ShellOptions) {
+    this.client = new Client();
+    this.defaultCwd = config.cwd;
+  }
+
+  async connect() {
+    return new Promise<void>((resolve, reject) => {
+      this.client.on('ready', () => {
+        resolve();
+      });
+
+      this.client.on('error', (err) => {
+        reject(err);
+      });
+
+      this.client.connect(this.config);
+    });
+  }
+
+  async execCommand(
+    givenCommand: string,
+    options: ExecCommandOptions = {}
+  ) {
+    return new Promise<ExecCommandResponse>((resolve, reject) => {
+      const env = { ...this.config.env, ...options.env };
+      const shell = this.config.shell || options.shell || null;
+      const shellCommand = shell ? `${shell} -c "${givenCommand}"` : givenCommand;
+      const cwd = options.cwd || this.defaultCwd;
+
+      if (cwd) {
+        // Prepend cd command if cwd is specified
+        const fullCommand = `cd ${cwd} && ${shellCommand}`;
+        this.client.exec(fullCommand, { env }, (err: Error | undefined, stream: ClientChannel) => {
+          if (err) {
+            reject(err);
+            return;
+          }
+
+          const {
+            noTrim = false
+          } = options;
+
+          let stdout: string[] = [];
+          let stderr: string[] = [];
+
+          stream.on('data', (data: Buffer) => {
+            stdout.push(data.toString());
+          });
+
+          stream.stderr.on('data', (data: Buffer) => {
+            stderr.push(data.toString());
+          });
+
+          stream.on('close', (code: number, signal: string | null) => {
+            const response: ExecCommandResponse = {
+              stdout: noTrim ? stdout.join('') : stdout.join('').trim(),
+              stderr: noTrim ? stderr.join('') : stderr.join('').trim(),
+              code,
+              signal
+            };
+            resolve(response);
+          });
+
+          stream.on('error', (err: Error) => {
+            reject(err);
+          });
+        });
+      } else {
+        this.client.exec(shellCommand, { env }, (err: Error | undefined, stream: ClientChannel) => {
+          if (err) {
+            reject(err);
+            return;
+          }
+
+          const {
+            noTrim = false
+          } = options;
+
+          let stdout: string[] = [];
+          let stderr: string[] = [];
+
+          stream.on('data', (data: Buffer) => {
+            stdout.push(data.toString());
+          });
+
+          stream.stderr.on('data', (data: Buffer) => {
+            stderr.push(data.toString());
+          });
+
+          stream.on('close', (code: number, signal: string | null) => {
+            const response: ExecCommandResponse = {
+              stdout: noTrim ? stdout.join('') : stdout.join('').trim(),
+              stderr: noTrim ? stderr.join('') : stderr.join('').trim(),
+              code,
+              signal
+            };
+            resolve(response);
+          });
+
+          stream.on('error', (err: Error) => {
+            reject(err);
+          });
+        });
+      }
+    });
+  }
+
+  async exec(command: string, parameters: string[], options: ExecCommandOptions = {}) {
+    const { stream = 'stdout', ...execOptions } = options;
+    const fullCommand = `${command} ${parameters.join(' ')}`;
+    const result = await this.execCommand(fullCommand, execOptions);
+
+    if (stream === 'both') {
+      return result;
+    }
+
+    return stream === 'stdout' ? result.stdout : result.stderr;
+  }
+
+  async disconnect() {
+    this.client.end();
+  }
+}

package/src/types.ts

@@ -0,0 +1,26 @@
+import { Readable } from 'stream';
+
+export interface ExecCommandOptions {
+  cwd?: string;
+  stdin?: string | Readable;
+  env?: Record<string, string>;
+  timeout?: number;
+  shell?: 'sh' | 'bash' | 'zsh' | 'powershell';
+  encoding?: BufferEncoding;
+  noTrim?: boolean;
+  onStdout?: (chunk: Buffer) => void;
+  onStderr?: (chunk: Buffer) => void;
+  stream?: 'stdout' | 'stderr' | 'both';
+}
+
+export interface ExecCommandResponse {
+  stdout: string;
+  stderr: string;
+  code: number | null;
+  signal: string | null;
+}
+
+export interface Shell {
+  execCommand(givenCommand: string, options?: ExecCommandOptions): Promise<ExecCommandResponse>;
+  exec(command: string, parameters: string[], options?: ExecCommandOptions): Promise<string | ExecCommandResponse>;
+}

package/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "rootDir": "./src",
+    "emitDeclarationOnly": true,
+    "declarationDir": "./dist/types"
+  },
+  "include": ["**/*"],
+  "exclude": ["dist", "node_modules", "**/*.test.ts"]
+}