@ps-aux/nodebup 0.1.1 → 0.3.0

package/lib/fs/path/Path.js

@@ -0,0 +1,59 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.RelativePath = exports.AbsPath = void 0;
+
+var _path = _interopRequireDefault(require("path"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _defineProperty(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; }
+
+class AbsPath {
+  constructor(path) {
+    this.path = path;
+
+    _defineProperty(this, "resolve", path => {
+      const str = typeof path === 'string' ? path : path.str();
+      return AbsPath.from(_path.default.resolve(this.str(), str));
+    });
+
+    _defineProperty(this, "parent", () => {
+      return AbsPath.from(_path.default.resolve(this.path, '..'));
+    });
+
+    _defineProperty(this, "str", () => this.path);
+
+    if (!_path.default.isAbsolute(path)) throw new Error(`Path ${path} must be absolute`);
+  }
+
+  toString() {
+    return `AbsPath(${this.str()})`;
+  }
+
+}
+
+exports.AbsPath = AbsPath;
+
+_defineProperty(AbsPath, "from", str => {
+  const p = new AbsPath(str);
+  return p;
+});
+
+class RelativePath {
+  constructor(path) {
+    this.path = path;
+
+    _defineProperty(this, "str", () => this.path);
+
+    if (_path.default.isAbsolute(path)) throw new Error(`Path ${path} must be relative`);
+  }
+
+} // AbsPath.prototype.toString = () => 'hovno'
+
+
+exports.RelativePath = RelativePath;
+
+_defineProperty(RelativePath, "from", str => new RelativePath(str));

package/lib/fs/readYaml.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.readYaml = void 0;
+
+var _fs = _interopRequireDefault(require("fs"));
+
+var _yaml = _interopRequireDefault(require("yaml"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const readYaml = path => {
+  const content = _fs.default.readFileSync(path).toString();
+
+  return _yaml.default.parse(content);
+};
+
+exports.readYaml = readYaml;

package/lib/globald.d.js

@@ -0,0 +1,3 @@
+"use strict";
+
+require("jest-extended");

package/lib/log/AppLogger.js

@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.AppLogger = void 0;
+
+var _ConsoleLogger = require("./ConsoleLogger");
+
+var _inversify = require("inversify");
+
+var _dec, _class;
+
+function _defineProperty(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; }
+
+let AppLogger = (_dec = (0, _inversify.injectable)(), _dec(_class = class AppLogger {
+  constructor() {
+    _defineProperty(this, "log", new _ConsoleLogger.ConsoleLogger());
+
+    _defineProperty(this, "debug", this.log.debug);
+
+    _defineProperty(this, "info", this.log.info);
+
+    _defineProperty(this, "error", this.log.error);
+  }
+
+}) || _class);
+exports.AppLogger = AppLogger;

package/lib/log/ConsoleLogger.js

@@ -11,15 +11,17 @@ class ConsoleLogger {
   constructor() {
     _defineProperty(this, "enabled", true);
 
+    _defineProperty(this, "print", (...args) => console.log(...args.map(a => a.toString())));
+
     _defineProperty(this, "debug", (...args) => {
-      if (this.enabled) console.log(...args);
+      if (this.enabled) this.print(args);
     });
 
     _defineProperty(this, "info", (...args) => {
-      if (this.enabled) console.log(...args);
+      if (this.enabled) this.print(args);
     });
 
-    _defineProperty(this, "error", console.error);
+    _defineProperty(this, "error", this.print);
 
     _defineProperty(this, "setEnabled", enabled => {
       this.enabled = enabled;

package/lib/log/MinimalLogger.js

@@ -8,11 +8,17 @@ exports.minimalLogger = void 0;
 function _defineProperty(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; }
 
 class MinimalLogger {
-  constructor() {
-    _defineProperty(this, "debug", () => {// no op
+  constructor(onlyError = true) {
+    this.onlyError = onlyError;
+
+    _defineProperty(this, "debug", (...args) => {
+      if (this.onlyError) return;
+      console.log(...args);
     });
 
-    _defineProperty(this, "info", () => {// no op
+    _defineProperty(this, "info", (...args) => {
+      if (this.onlyError) return;
+      console.log(...args);
     });
 
     _defineProperty(this, "error", console.error);
@@ -20,6 +26,6 @@ class MinimalLogger {
 
 }
 
-const minimalLogger = () => new MinimalLogger();
+const minimalLogger = (onlyError = true) => new MinimalLogger(onlyError);
 
 exports.minimalLogger = minimalLogger;

package/lib/storage/StorageBackendProvider.js

@@ -0,0 +1,53 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.StorageBackendProvider = void 0;
+
+var _inversify = require("inversify");
+
+var _FsSyncer = require("../fs/fssync/FsSyncer");
+
+var _LocalFileStorageBackend = require("./local-file/LocalFileStorageBackend");
+
+var _ContextSymbols = require("../ctx/ContextSymbols");
+
+var _Config = require("../config/Config");
+
+var _ResticClientFactory = require("./restic/ResticClientFactory");
+
+var _ResticStorageBackend = require("./restic/ResticStorageBackend");
+
+var _Fs = require("../fs/Fs");
+
+var _dec, _dec2, _dec3, _dec4, _class;
+
+function _defineProperty(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; }
+
+let StorageBackendProvider = (_dec = (0, _inversify.injectable)(), _dec2 = function (target, key) {
+  return (0, _inversify.inject)(_ContextSymbols.AppConfig_)(target, undefined, 3);
+}, _dec3 = Reflect.metadata("design:type", Function), _dec4 = Reflect.metadata("design:paramtypes", [typeof _FsSyncer.FsSyncer === "undefined" ? Object : _FsSyncer.FsSyncer, typeof _ResticClientFactory.ResticClientFactory === "undefined" ? Object : _ResticClientFactory.ResticClientFactory, typeof _Fs.Fs === "undefined" ? Object : _Fs.Fs, typeof _Config.Config === "undefined" ? Object : _Config.Config]), _dec(_class = _dec2(_class = _dec3(_class = _dec4(_class = class StorageBackendProvider {
+  constructor(fsSyncer, resticFac, fs, cfg) {
+    this.fsSyncer = fsSyncer;
+    this.resticFac = resticFac;
+    this.fs = fs;
+    this.cfg = cfg;
+
+    _defineProperty(this, "provide", name => {
+      const s = this.cfg.storage.find(s => s.name === name);
+      if (!s) throw new Error(`No such storage '${name}'`);
+      if (s.type === 'restic') return this.restic(s);else if (s.type === 'file') return this.localFile(s);else throw new Error(`Unsupported storage type ${s.type}`);
+    });
+
+    _defineProperty(this, "restic", cfg => {
+      return new _ResticStorageBackend.ResticStorageBackend(this.resticFac.create(cfg));
+    });
+
+    _defineProperty(this, "localFile", cfg => {
+      return new _LocalFileStorageBackend.LocalFileStorageBackend(this.fsSyncer, cfg.path);
+    });
+  }
+
+}) || _class) || _class) || _class) || _class);
+exports.StorageBackendProvider = StorageBackendProvider;

package/lib/storage/local-file/LocalFileStorageBackend.js

@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.LocalFileStorageBackend = void 0;
+
+function _defineProperty(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; }
+
+class LocalFileStorageBackend {
+  constructor(fsSyncer, dst) {
+    this.fsSyncer = fsSyncer;
+    this.dst = dst;
+
+    _defineProperty(this, "store", from => {
+      this.fsSyncer.syncDirs(from, this.dst);
+    });
+  }
+
+}
+
+exports.LocalFileStorageBackend = LocalFileStorageBackend;

package/lib/storage/restic/ResticClient.js

@@ -0,0 +1,86 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ResticClient = void 0;
+
+var _inversify = require("inversify");
+
+var _types = require("../../types");
+
+var _ContextSymbols = require("../../ctx/ContextSymbols");
+
+var _Shell = require("../../tools/shell/Shell");
+
+var _dec, _dec2, _dec3, _dec4, _class;
+
+function _defineProperty(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; }
+
+const normalizeUrl = url => {
+  if (url.startsWith('local:')) {
+    url = url.replace(/^local:/, '');
+  }
+
+  return url;
+};
+/**
+ * Tested with: restic 0.9.6 compiled with go1.12.12 on linux/amd64
+ * TODO forwarding stdout to the logger
+ */
+
+
+let ResticClient = (_dec = (0, _inversify.injectable)(), _dec2 = function (target, key) {
+  return (0, _inversify.inject)(_ContextSymbols.TaskConfig_)(target, undefined, 2);
+}, _dec3 = Reflect.metadata("design:type", Function), _dec4 = Reflect.metadata("design:paramtypes", [typeof ResticConfig === "undefined" ? Object : ResticConfig, typeof _Shell.Shell === "undefined" ? Object : _Shell.Shell, typeof _types.Log === "undefined" ? Object : _types.Log]), _dec(_class = _dec2(_class = _dec3(_class = _dec4(_class = class ResticClient {
+  constructor(cfg, shell, log) {
+    this.cfg = cfg;
+    this.shell = shell;
+    this.log = log;
+
+    _defineProperty(this, "url", void 0);
+
+    _defineProperty(this, "prepareRepo", () => {
+      this.log.info(`Preparing a restic repo at '${this.url}`);
+      this.shell.exec(`restic init`, {
+        env: this.env()
+      });
+    });
+
+    _defineProperty(this, "backup", (cwd, from) => {
+      this.shell.exec(`restic backup ${from.str()}`, {
+        cwd: cwd.str(),
+        env: this.env()
+      });
+    });
+
+    _defineProperty(this, "restore", to => {
+      this.shell.exec(`restic restore latest --target ${to.str()}`, {
+        env: this.env()
+      });
+    });
+
+    _defineProperty(this, "env", () => ({
+      RESTIC_PASSWORD: this.cfg.repo.password,
+      RESTIC_REPOSITORY: this.url,
+      ...this.getCredentialsForUrl(this.url)
+    }));
+
+    _defineProperty(this, "getCredentialsForUrl", url => {
+      if (url.startsWith('b2:')) {
+        const cfg = this.cfg.backblaze;
+        if (!cfg) throw new Error(`Repo url ${url} refers to Backblaze but no Backblaze config provided`);
+        return {
+          B2_ACCOUNT_ID: cfg.accountId,
+          B2_ACCOUNT_KEY: cfg.accountKey
+        };
+      }
+
+      return {};
+    });
+
+    this.url = normalizeUrl(cfg.repo.url);
+  }
+
+}) || _class) || _class) || _class) || _class);
+exports.ResticClient = ResticClient;

package/lib/storage/restic/ResticClient.spec.js

@@ -0,0 +1,91 @@
+"use strict";
+
+var _ResticClient = require("./ResticClient");
+
+var _AppLogger = require("../../log/AppLogger");
+
+var _Shell = require("../../tools/shell/Shell");
+
+var _test = require("../../../test");
+
+var _fs = _interopRequireDefault(require("fs"));
+
+var _path = _interopRequireDefault(require("path"));
+
+var _Path = require("../../fs/path/Path");
+
+var _dirCompare = require("dir-compare");
+
+var _testHelper = require("../../../test/testHelper");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const getBackblazeConfig = () => {
+  const path = _path.default.resolve(__dirname, '../../../.keys.json');
+
+  if (!_fs.default.existsSync(path)) return undefined;
+  const data = JSON.parse(_fs.default.readFileSync(path).toString());
+  return {
+    accountId: data.restic.backblaze.keyID,
+    accountKey: data.restic.backblaze.applicationKey
+  };
+};
+
+describe('ResticClient', () => {
+  const l = new _AppLogger.AppLogger();
+  const password = 'foo123';
+  const backupDir = (0, _test.testDir)('backup-me');
+  describe('local', () => {
+    const repoDir = (0, _test.testdataDir)('my-repo');
+    const restoreDir = (0, _test.testdataDir)('restore/local');
+    const sut = new _ResticClient.ResticClient({
+      repo: {
+        password,
+        url: `local:${repoDir}`
+      }
+    }, new _Shell.Shell(l), l);
+    afterAll(() => {
+      (0, _testHelper.cleanDir)(repoDir);
+      (0, _testHelper.cleanDir)(restoreDir);
+    });
+    it('create repo', () => {
+      sut.prepareRepo();
+    });
+    it('push data', () => {
+      sut.backup(_Path.AbsPath.from(backupDir), _Path.RelativePath.from('.'));
+    });
+    it('restore data', () => {
+      sut.restore(_Path.AbsPath.from(restoreDir));
+      const res = (0, _dirCompare.compareSync)(backupDir, restoreDir);
+      expect(res.same).toBeTrue();
+    });
+  });
+  describe('b2', () => {
+    const b2Cfg = getBackblazeConfig();
+
+    if (!b2Cfg) {
+      console.log('No B2 config - skipping');
+      return;
+    }
+
+    const restoreDir = (0, _test.testdataDir)('restore/b2');
+    const repoUrl = `b2:psaux-nodepub-test`;
+    const sut = new _ResticClient.ResticClient({
+      repo: {
+        password,
+        url: repoUrl
+      },
+      backblaze: b2Cfg
+    }, new _Shell.Shell(l), l);
+    afterAll(() => {
+      (0, _testHelper.cleanDir)(restoreDir);
+    });
+    it('push adn restore data', () => {
+      //     sut.prepareRepo(repoUrl, password)
+      sut.backup(_Path.AbsPath.from(backupDir), _Path.RelativePath.from('.'));
+      sut.restore(_Path.AbsPath.from(restoreDir));
+      const res = (0, _dirCompare.compareSync)(backupDir, restoreDir);
+      expect(res.same).toBeTrue();
+    });
+  });
+});

package/lib/storage/restic/ResticClientFactory.js

@@ -0,0 +1,77 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ResticClientFactory = void 0;
+
+var _inversify = require("inversify");
+
+var _ResticClient = require("./ResticClient");
+
+var _Shell = require("../../tools/shell/Shell");
+
+var _AppLogger = require("../../log/AppLogger");
+
+var _Fs = require("../../fs/Fs");
+
+var _joi = _interopRequireDefault(require("@hapi/joi"));
+
+var _dec, _dec2, _dec3, _class;
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _defineProperty(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; }
+
+const CredentialsFileSchema = _joi.default.object({
+  keyID: _joi.default.string(),
+  keyName: _joi.default.string().optional(),
+  applicationKey: _joi.default.string()
+});
+
+const validateCredentials = obj => {
+  const r = CredentialsFileSchema.validate(obj, {
+    presence: 'required',
+    allowUnknown: false
+  });
+  return r.error ? JSON.stringify(r.error) : null;
+};
+
+let ResticClientFactory = (_dec = (0, _inversify.injectable)(), _dec2 = Reflect.metadata("design:type", Function), _dec3 = Reflect.metadata("design:paramtypes", [typeof _Shell.Shell === "undefined" ? Object : _Shell.Shell, typeof _AppLogger.AppLogger === "undefined" ? Object : _AppLogger.AppLogger, typeof _Fs.Fs === "undefined" ? Object : _Fs.Fs]), _dec(_class = _dec2(_class = _dec3(_class = class ResticClientFactory {
+  constructor(sh, log, fs) {
+    this.sh = sh;
+    this.log = log;
+    this.fs = fs;
+
+    _defineProperty(this, "create", cfg => {
+      const password = this.fs.readFile(cfg.passwordFile).trim();
+      const props = {
+        repo: {
+          password,
+          url: cfg.repo
+        }
+      };
+
+      if (cfg.credentialsFile) {
+        if (!cfg.repo.startsWith('b2:')) throw new Error('Credentials can be supported only for the B2 restic backend');
+        const credJson = this.fs.readJson(cfg.credentialsFile); //
+
+        const validationErr = validateCredentials(credJson);
+
+        if (validationErr) {
+          throw new Error(`Invalid Restic credential in ${cfg.credentialsFile}: ${validationErr}`);
+        }
+
+        const creds = credJson;
+        props.backblaze = {
+          accountId: creds.keyID,
+          accountKey: creds.applicationKey
+        };
+      }
+
+      return new _ResticClient.ResticClient(props, this.sh, this.log);
+    });
+  }
+
+}) || _class) || _class) || _class);
+exports.ResticClientFactory = ResticClientFactory;

package/lib/storage/restic/ResticController.js

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ResticController = void 0;
+
+var _inversify = require("inversify");
+
+var _ContextSymbols = require("../../ctx/ContextSymbols");
+
+var _Config = require("../../config/Config");
+
+var _ResticClientFactory = require("./ResticClientFactory");
+
+var _AppLogger = require("../../log/AppLogger");
+
+var _dec, _dec2, _dec3, _dec4, _class;
+
+function _defineProperty(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; }
+
+let ResticController = (_dec = (0, _inversify.injectable)(), _dec2 = function (target, key) {
+  return (0, _inversify.inject)(_ContextSymbols.AppConfig_)(target, undefined, 2);
+}, _dec3 = Reflect.metadata("design:type", Function), _dec4 = Reflect.metadata("design:paramtypes", [typeof _ResticClientFactory.ResticClientFactory === "undefined" ? Object : _ResticClientFactory.ResticClientFactory, typeof _AppLogger.AppLogger === "undefined" ? Object : _AppLogger.AppLogger, typeof _Config.Config === "undefined" ? Object : _Config.Config]), _dec(_class = _dec2(_class = _dec3(_class = _dec4(_class = class ResticController {
+  constructor(restFact, log, cfg) {
+    this.restFact = restFact;
+    this.log = log;
+    this.cfg = cfg;
+
+    _defineProperty(this, "initRepo", storageName => {
+      const s = this.cfg.storage.filter(s => s.type === 'restic').find(s => s.name === storageName);
+      if (!s) throw new Error(`No restic storage '${storageName}'`);
+      this.log.info('Initializing repo', storageName);
+      this.restFact.create(s).prepareRepo();
+    });
+  }
+
+}) || _class) || _class) || _class) || _class);
+exports.ResticController = ResticController;

package/lib/storage/restic/ResticStorageBackend.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ResticStorageBackend = void 0;
+
+var _Path = require("../../fs/path/Path");
+
+function _defineProperty(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; }
+
+class ResticStorageBackend {
+  constructor(client) {
+    this.client = client;
+
+    _defineProperty(this, "store", from => {
+      this.client.backup(from, _Path.RelativePath.from('.'));
+    });
+  }
+
+}
+
+exports.ResticStorageBackend = ResticStorageBackend;

package/lib/storage/types.d.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/lib/tools/gpg/Gpg.js

@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Gpg = void 0;
+
+var _Shell = require("../shell/Shell");
+
+var _inversify = require("inversify");
+
+var _dec, _dec2, _dec3, _class;
+
+function _defineProperty(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; }
+
+let Gpg = (_dec = (0, _inversify.injectable)(), _dec2 = Reflect.metadata("design:type", Function), _dec3 = Reflect.metadata("design:paramtypes", [typeof _Shell.Shell === "undefined" ? Object : _Shell.Shell]), _dec(_class = _dec2(_class = _dec3(_class = class Gpg {
+  constructor(sh) {
+    this.sh = sh;
+
+    _defineProperty(this, "exportKey", id => {
+      const res = this.sh.execAndReturnVal(`gpg --export-secret-key --armor ${id}`);
+      if (!res) throw new Error(`Key '${id}' not in  keyring`);
+      return res;
+    });
+  }
+
+}) || _class) || _class) || _class);
+exports.Gpg = Gpg;

package/lib/tools/gpg/Gpg.spec.js

@@ -0,0 +1,14 @@
+"use strict";
+
+var _AppLogger = require("../../log/AppLogger");
+
+var _Gpg = require("./Gpg");
+
+var _Shell = require("../shell/Shell");
+
+// TODO find a way hot to provide prompt via stdin
+it.skip('works', () => {
+  const sut = new _Gpg.Gpg(new _Shell.Shell(new _AppLogger.AppLogger()));
+  const key = sut.exportKey('john.doe@foo.com');
+  console.log('key', key);
+});

package/lib/tools/shell/Shell.js

@@ -0,0 +1,52 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Shell = void 0;
+
+var _shellCmd = require("./shellCmd");
+
+var _inversify = require("inversify");
+
+var _AppLogger = require("../../log/AppLogger");
+
+var _dec, _dec2, _dec3, _class;
+
+function _defineProperty(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; }
+
+// TODO copy pasted from my other project
+let Shell = (_dec = (0, _inversify.injectable)(), _dec2 = Reflect.metadata("design:type", Function), _dec3 = Reflect.metadata("design:paramtypes", [typeof _AppLogger.AppLogger === "undefined" ? Object : _AppLogger.AppLogger]), _dec(_class = _dec2(_class = _dec3(_class = class Shell {
+  constructor(log) {
+    this.log = log;
+
+    _defineProperty(this, "exec", (cmd, opts = {}) => {
+      this.log.debug(cmd);
+      (0, _shellCmd.shellCmd)(cmd, { ...opts,
+        returnStdout: false
+      });
+    });
+
+    _defineProperty(this, "execWithStdIn", ({
+      cmd,
+      stdin,
+      opts = {}
+    }) => {
+      this.log.debug(`"${stdin}" > ${cmd}`);
+      (0, _shellCmd.shellCmd)(cmd, { ...opts,
+        stdin,
+        returnStdout: false
+      });
+    });
+
+    _defineProperty(this, "execAndReturnVal", (cmd, ops = {}) => {
+      this.log.debug(cmd, '[stdout consumed]');
+      return (0, _shellCmd.shellCmd)(cmd, {
+        returnStdout: true,
+        ...ops
+      });
+    });
+  }
+
+}) || _class) || _class) || _class);
+exports.Shell = Shell;