@ps-aux/nodebup 0.1.1 → 0.2.0

package/lib/bup/TaskRunner.js

@@ -0,0 +1,82 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TaskRunner = void 0;
+
+var _FsSyncer = require("../fs/fssync/FsSyncer");
+
+var _Config = require("../config/Config");
+
+var _Gpg = require("../tools/gpg/Gpg");
+
+var _Fs = require("../fs/Fs");
+
+var _SshKeyManager = require("../tools/ssh/SshKeyManager");
+
+var _inversify = require("inversify");
+
+var _ContextSymbols = require("../ctx/ContextSymbols");
+
+var _PlainCopyDataStorage = require("../storage/PlainCopyDataStorage");
+
+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 TaskRunner = (_dec = (0, _inversify.injectable)(), _dec2 = function (target, key) {
+  return (0, _inversify.inject)(_ContextSymbols.TaskConfig_)(target, undefined, 6);
+}, _dec3 = Reflect.metadata("design:type", Function), _dec4 = Reflect.metadata("design:paramtypes", [typeof _FsSyncer.FsSyncer === "undefined" ? Object : _FsSyncer.FsSyncer, typeof _Gpg.Gpg === "undefined" ? Object : _Gpg.Gpg, typeof _SshKeyManager.SshKeyManager === "undefined" ? Object : _SshKeyManager.SshKeyManager, typeof _Fs.Fs === "undefined" ? Object : _Fs.Fs, typeof _PlainCopyDataStorage.PlainCopyDataStorage === "undefined" ? Object : _PlainCopyDataStorage.PlainCopyDataStorage, typeof _AppLogger.AppLogger === "undefined" ? Object : _AppLogger.AppLogger, typeof _Config.Tasks === "undefined" ? Object : _Config.Tasks]), _dec(_class = _dec2(_class = _dec3(_class = _dec4(_class = class TaskRunner {
+  constructor(sync, gpg, ssh, fs, storage, log, tasks) {
+    this.sync = sync;
+    this.gpg = gpg;
+    this.ssh = ssh;
+    this.fs = fs;
+    this.storage = storage;
+    this.log = log;
+    this.tasks = tasks;
+
+    _defineProperty(this, "runAll", async () => {
+      const tasks = this.tasks;
+
+      if (tasks.file.length > 0) {
+        for (const t of tasks.file) {
+          await this.runFileTask(t);
+        }
+      }
+
+      return; // eslint-disable-next-line no-unreachable
+
+      if (tasks.gpgKey.length > 0) tasks.gpgKey.forEach(this.runGpgKeyTask);
+      if (tasks.sshKey.length > 0) tasks.sshKey.forEach(this.runSshKeyTask);
+    });
+
+    _defineProperty(this, "runGpgKeyTask", t => {
+      this.log.info('Running GPG key task', t);
+      const key = this.gpg.exportKey(t.id);
+      const to = this.storagePath(t.to || `keys/gpg/${t.id}.asc`);
+      this.fs.writeFile(to, key);
+    });
+
+    _defineProperty(this, "runSshKeyTask", t => {
+      this.log.info('Running SSH key task', t);
+      const key = this.ssh.exportKey(t.id);
+      const to = this.storagePath(t.to || `keys/ssh/${t.id}`);
+      this.fs.writeFile(to, key);
+    });
+
+    _defineProperty(this, "runFileTask", async t => {
+      this.log.info('Running file task', t);
+      this.storage.store(t.from, t.to);
+    });
+
+    _defineProperty(this, "storagePath", path => {
+      throw new Error('Unspported');
+    });
+  }
+
+}) || _class) || _class) || _class) || _class);
+exports.TaskRunner = TaskRunner;

package/lib/cli/app.js

@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createApp = void 0;
+
+require("reflect-metadata");
+
+var _nclif = require("@ps-aux/nclif");
+
+var _Config = require("../config/Config");
+
+var _Context = require("../ctx/Context");
+
+var _TaskRunner = require("../bup/TaskRunner");
+
+const createApp = () => _nclif.CliApp.of({
+  options: [],
+  commands: {
+    go: (0, _nclif.cmd)({
+      description: 'Run backup',
+      run: (_, ctx) => ctx.get(_TaskRunner.TaskRunner).runAll()
+    })
+  }
+}).addObjectConfig(pwd => (0, _Config.readConfig)(pwd + '/bup.yaml')).context(({
+  config
+}) => (0, _Context.createContext)(config));
+
+exports.createApp = createApp;

package/lib/cli/bin.js

@@ -1,12 +1,6 @@
 #!/usr/bin/env node
 "use strict";
 
-var _entrypoint = _interopRequireDefault(require("./entrypoint"));
+var _app = require("./app");
 
-var _Context = require("../ctx/Context");
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-const rootDir = process.cwd();
-const ctx = (0, _Context.createContext)(rootDir);
-(0, _entrypoint.default)(ctx);
+(0, _app.createApp)().run();

package/lib/config/Config.js

@@ -0,0 +1,41 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.readConfig = void 0;
+
+var _Path = require("../fs/path/Path");
+
+var _readYaml = require("../fs/readYaml");
+
+var _validateConfigAgainstSchema = require("./validateConfigAgainstSchema");
+
+var _expandPath = require("./expandPath");
+
+const readConfig = path => {
+  const file = _Path.AbsPath.from(path);
+
+  const obj = (0, _readYaml.readYaml)(file.str());
+  (0, _validateConfigAgainstSchema.validateConfigAgainstSchema)(obj);
+  const rootDir = file.parent();
+
+  const expand = str => {
+    const p = (0, _expandPath.expandPath)(str, rootDir);
+    return p;
+  };
+
+  if (!obj.tasks.file) obj.tasks.file = [];
+  if (!obj.tasks.gpgKey) obj.tasks.gpgKey = [];
+  if (!obj.tasks.sshKey) obj.tasks.sshKey = [];
+  obj.tasks.file.forEach(t => {
+    t.from = expand(t.from);
+    t.to = _Path.RelativePath.from(t.to);
+  });
+  obj.storage.forEach(s => {
+    s.path = expand(s.path);
+  });
+  return obj;
+};
+
+exports.readConfig = readConfig;

package/lib/config/expandPath.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.expandPath = void 0;
+
+var _Path = require("../fs/path/Path");
+
+var _os = _interopRequireDefault(require("os"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const expandPath = (path, rootDir) => {
+  path = path.replace('<cwd>', rootDir.str);
+  path = path.replace('~', _os.default.homedir());
+  return _Path.AbsPath.from(path);
+};
+
+exports.expandPath = expandPath;

package/lib/config/validateConfigAgainstSchema.js

@@ -0,0 +1,46 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.validateConfigAgainstSchema = void 0;
+
+var _joi = _interopRequireDefault(require("@hapi/joi"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const DirTaskSchema = _joi.default.object({
+  from: _joi.default.string(),
+  to: _joi.default.string()
+});
+
+const FileTaskSchema = DirTaskSchema;
+
+const KeyTaskSchema = _joi.default.object({
+  id: _joi.default.string(),
+  to: _joi.default.string().optional()
+});
+
+const StorageSchema = _joi.default.object({
+  path: _joi.default.string()
+});
+
+const Schema = () => _joi.default.object({
+  storage: _joi.default.array().items(StorageSchema),
+  tasks: _joi.default.object({
+    dir: _joi.default.array().items(DirTaskSchema).optional(),
+    file: _joi.default.array().items(FileTaskSchema).optional(),
+    gpgKey: _joi.default.array().items(KeyTaskSchema).optional(),
+    sshKey: _joi.default.array().items(KeyTaskSchema).optional()
+  })
+});
+
+const validateConfigAgainstSchema = cfg => {
+  const r = Schema().validate(cfg, {
+    presence: 'required',
+    allowUnknown: false
+  });
+  if (r.error) throw new Error('Invalid config.' + r.error.message);
+};
+
+exports.validateConfigAgainstSchema = validateConfigAgainstSchema;

package/lib/ctx/Context.js

@@ -5,32 +5,37 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.createContext = void 0;
 
-var _ConsoleLogger = require("../log/ConsoleLogger");
+var _Shell = require("../tools/shell/Shell");
 
-var _LocalShellCmdExecutor = require("../shell/LocalShellCmdExecutor");
+var _FsSyncer = require("../fs/fssync/FsSyncer");
 
-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; }
+var _Gpg = require("../tools/gpg/Gpg");
 
-class ContextImpl {
-  constructor(rootDir) {
-    _defineProperty(this, "_log", void 0);
+var _Fs = require("../fs/Fs");
 
-    _defineProperty(this, "sh", void 0);
+var _SshKeyManager = require("../tools/ssh/SshKeyManager");
 
-    _defineProperty(this, "shell", () => this.sh);
+var _inversify = require("inversify");
 
-    _defineProperty(this, "log", () => this._log);
+var _PlainCopyDataStorage = require("../storage/PlainCopyDataStorage");
 
-    _defineProperty(this, "now", () => new Date());
+var _ContextSymbols = require("./ContextSymbols");
 
-    this._log = new _ConsoleLogger.ConsoleLogger();
-    this.sh = new _LocalShellCmdExecutor.LocalShellCmdExecutor(this._log);
-  }
+var _TaskRunner = require("../bup/TaskRunner");
 
-}
+var _AppLogger = require("../log/AppLogger");
 
-const createContext = rootDir => {
-  return new ContextImpl(rootDir);
+const createContext = cfg => {
+  if (cfg.storage.length !== 1) throw new Error('Exactly one storage path is required');
+  const c = new _inversify.Container();
+  c.bind(_ContextSymbols.TaskConfig_).toConstantValue(cfg.tasks);
+  c.bind(_ContextSymbols.StorageConfig_).toConstantValue(cfg.storage[0]);
+  const log = new _AppLogger.AppLogger();
+  c.bind(_ContextSymbols.Log_).toConstantValue(log);
+  c.bind(_AppLogger.AppLogger).toConstantValue(log);
+  const self = [_Gpg.Gpg, _Shell.Shell, _Fs.Fs, _FsSyncer.FsSyncer, _SshKeyManager.SshKeyManager, _PlainCopyDataStorage.PlainCopyDataStorage, _TaskRunner.TaskRunner];
+  self.forEach(s => c.bind(s).toSelf());
+  return c;
 };
 
 exports.createContext = createContext;

package/lib/ctx/ContextSymbols.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TaskConfig_ = exports.StorageConfig_ = exports.Log_ = void 0;
+const Log_ = Symbol.for('Log');
+exports.Log_ = Log_;
+const TaskConfig_ = Symbol.for('config.Tasks');
+exports.TaskConfig_ = TaskConfig_;
+const StorageConfig_ = Symbol.for('config.Storage');
+exports.StorageConfig_ = StorageConfig_;

package/lib/fs/Fs.js

@@ -0,0 +1,60 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Fs = void 0;
+
+var _fs = _interopRequireDefault(require("fs"));
+
+var _inversify = require("inversify");
+
+var _AppLogger = require("../log/AppLogger");
+
+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; }
+
+let Fs = (_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 Fs {
+  constructor(log) {
+    this.log = log;
+
+    _defineProperty(this, "writeFile", (path, content) => {
+      this.log.debug('Writing into file', path);
+      this.ensureParentDir(path);
+
+      _fs.default.writeFileSync(path.str(), content);
+    });
+
+    _defineProperty(this, "isFile", path => !_fs.default.lstatSync(path.str()).isDirectory());
+
+    _defineProperty(this, "readFile", path => {
+      this.log.debug('Reading from file', path.str);
+      return _fs.default.readFileSync(path.str()).toString();
+    });
+
+    _defineProperty(this, "ensureDir", path => {
+      if (!this.exists(path)) {
+        this.log.debug('Dir ', path, 'does not exist. Wil be created');
+
+        _fs.default.mkdirSync(path.str(), {
+          recursive: true
+        });
+      } else {
+        if (this.isFile(path)) throw new Error(`${path.str()} exists and is not a directory`);
+      }
+    });
+
+    _defineProperty(this, "ensureParentDir", path => {
+      const parent = path.parent();
+      if (this.exists(parent)) return;
+      this.ensureDir(parent);
+    });
+
+    _defineProperty(this, "exists", path => _fs.default.existsSync(path.str()));
+  }
+
+}) || _class) || _class) || _class);
+exports.Fs = Fs;

package/lib/fs/areDirsSame.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.areDirsSame = void 0;
+
+var _dirCompare = require("dir-compare");
+
+const opts = {
+  compareContent: true,
+  compareDate: true
+};
+
+const areDirsSame = (a, b) => {
+  const res = (0, _dirCompare.compareSync)(a.str(), b.str(), opts);
+  return res.same;
+};
+
+exports.areDirsSame = areDirsSame;

package/lib/fs/areDirsSame.test.js

@@ -0,0 +1,20 @@
+"use strict";
+
+var _areDirsSame = require("./areDirsSame");
+
+var _test = require("../../test");
+
+var _Path = require("./path/Path");
+
+const thisDir = _Path.AbsPath.from(__dirname);
+
+it('same', () => {
+  const res = (0, _areDirsSame.areDirsSame)(thisDir, thisDir);
+  expect(res).toBe(true);
+});
+it('not same', () => {
+  const otherDir = _Path.AbsPath.from((0, _test.testDir)());
+
+  const res = (0, _areDirsSame.areDirsSame)(thisDir, otherDir);
+  expect(res).toBe(false);
+});

package/lib/fs/fssync/FsSync.spec.js

@@ -0,0 +1,37 @@
+"use strict";
+
+var _FsSyncer = require("./FsSyncer");
+
+var _Shell = require("../../tools/shell/Shell");
+
+var _test = require("../../../test");
+
+var _fs = _interopRequireDefault(require("fs"));
+
+var _areDirsSame = require("../areDirsSame");
+
+var _Fs = require("../Fs");
+
+var _Path = require("../path/Path");
+
+var _AppLogger = require("../../log/AppLogger");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+describe('FsSync', () => {
+  const from = _Path.AbsPath.from((0, _test.testDir)('fs/fssync/src'));
+
+  const to = _Path.AbsPath.from((0, _test.testDir)('fs/fssync/dst/inner'));
+
+  it('syncs dir', () => {
+    const l = new _AppLogger.AppLogger();
+    const sut = new _FsSyncer.FsSyncer(new _Shell.Shell(l), new _Fs.Fs(l), l);
+    sut.syncDirs(from, to);
+    expect((0, _areDirsSame.areDirsSame)(from, to)).toBe(true);
+  });
+  afterAll(() => {
+    _fs.default.rmdirSync(to.str(), {
+      recursive: true
+    });
+  });
+});

package/lib/fs/fssync/FsSyncer.js

@@ -0,0 +1,48 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.FsSyncer = void 0;
+
+var _Shell = require("../../tools/shell/Shell");
+
+var _Fs = require("../Fs");
+
+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; }
+
+const toUnixDirString = path => {
+  const val = path.str();
+  if (val.endsWith('/')) return val;
+  return val + '/';
+};
+
+let FsSyncer = (_dec = (0, _inversify.injectable)(), _dec2 = Reflect.metadata("design:type", Function), _dec3 = Reflect.metadata("design:paramtypes", [typeof _Shell.Shell === "undefined" ? Object : _Shell.Shell, typeof _Fs.Fs === "undefined" ? Object : _Fs.Fs, typeof _AppLogger.AppLogger === "undefined" ? Object : _AppLogger.AppLogger]), _dec(_class = _dec2(_class = _dec3(_class = class FsSyncer {
+  constructor(sh, fs, log) {
+    this.sh = sh;
+    this.fs = fs;
+    this.log = log;
+
+    _defineProperty(this, "syncDirs", (from, to) => {
+      this.log.info('Syncing dir', from.str(), '==>', to.str());
+      const fromPath = toUnixDirString(from);
+      const toPath = toUnixDirString(to);
+      this.fs.ensureParentDir(to);
+      this.sh.exec(`rsync -rtv ${fromPath} ${toPath}`);
+    });
+
+    _defineProperty(this, "syncFile", (from, to) => {
+      this.log.info('Syncing file', from.str(), '==>', to.str());
+      this.fs.ensureParentDir(to);
+      this.sh.exec(`rsync -rtv ${from.str()} ${to.str()}`);
+    });
+  }
+
+}) || _class) || _class) || _class);
+exports.FsSyncer = FsSyncer;

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/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/PlainCopyDataStorage.js

@@ -0,0 +1,40 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.PlainCopyDataStorage = void 0;
+
+var _inversify = require("inversify");
+
+var _FsSyncer = require("../fs/fssync/FsSyncer");
+
+var _Config = require("../config/Config");
+
+var _ContextSymbols = require("../ctx/ContextSymbols");
+
+var _Fs = require("../fs/Fs");
+
+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 PlainCopyDataStorage = (_dec = (0, _inversify.injectable)(), _dec2 = function (target, key) {
+  return (0, _inversify.inject)(_ContextSymbols.StorageConfig_)(target, undefined, 1);
+}, _dec3 = Reflect.metadata("design:type", Function), _dec4 = Reflect.metadata("design:paramtypes", [typeof _FsSyncer.FsSyncer === "undefined" ? Object : _FsSyncer.FsSyncer, typeof _Config.StorageInstance === "undefined" ? Object : _Config.StorageInstance, typeof _Fs.Fs === "undefined" ? Object : _Fs.Fs, typeof _AppLogger.AppLogger === "undefined" ? Object : _AppLogger.AppLogger]), _dec(_class = _dec2(_class = _dec3(_class = _dec4(_class = class PlainCopyDataStorage {
+  constructor(fsSyncer, storage, fs, log) {
+    this.fsSyncer = fsSyncer;
+    this.storage = storage;
+    this.fs = fs;
+    this.log = log;
+
+    _defineProperty(this, "store", async (from, to) => {
+      this.log.info(`Storing ${from} to ${to}`);
+      if (this.fs.isFile(from)) this.fsSyncer.syncFile(from, this.storage.path.resolve(to));else this.fsSyncer.syncDirs(from, this.storage.path.resolve(to));
+    });
+  }
+
+}) || _class) || _class) || _class) || _class);
+exports.PlainCopyDataStorage = PlainCopyDataStorage;

package/lib/storage/restic/ResticClient.js

@@ -0,0 +1,70 @@
+"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;
+};
+/**
+ * TODO forwarding stdout to the logger
+ */
+
+
+let ResticClient = (_dec = (0, _inversify.injectable)(), _dec2 = function (target, key) {
+  return (0, _inversify.inject)(_ContextSymbols.TaskConfig_)(target, undefined, 1);
+}, _dec3 = Reflect.metadata("design:type", Function), _dec4 = Reflect.metadata("design:paramtypes", [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(shell, log) {
+    this.shell = shell;
+    this.log = log;
+
+    _defineProperty(this, "prepareRepo", (url, password) => {
+      url = normalizeUrl(url);
+      this.log.info('Preparing a restic repo', url);
+      this.shell.exec(`restic init --repo ${url}`, {
+        env: {
+          RESTIC_PASSWORD: password
+        }
+      });
+    });
+
+    _defineProperty(this, "backup", (url, cwd, from, password) => {
+      url = normalizeUrl(url);
+      this.shell.exec(`restic --repo ${url} backup ${from.str()}`, {
+        cwd: cwd.str(),
+        env: {
+          RESTIC_PASSWORD: password
+        }
+      });
+    });
+
+    _defineProperty(this, "restore", (url, to, password) => {
+      url = normalizeUrl(url);
+      this.shell.exec(`restic --repo ${url} restore latest --target ${to.str()}`, {
+        env: {
+          RESTIC_PASSWORD: password
+        }
+      });
+    });
+  }
+
+}) || _class) || _class) || _class) || _class);
+exports.ResticClient = ResticClient;

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

@@ -0,0 +1,50 @@
+"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 = require("../../fs/path/Path");
+
+var _dirCompare = require("dir-compare");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/*
+ * Tested with: restic 0.9.6 compiled with go1.12.12 on linux/amd64
+ */
+describe.skip('ResticClient', () => {
+  const l = new _AppLogger.AppLogger();
+  const sut = new _ResticClient.ResticClient(new _Shell.Shell(l), l);
+  const password = 'foo123';
+  const repoDir = (0, _test.testdataDir)('my-repo');
+  const backupDir = (0, _test.testDir)('backup-me');
+  const restoreDir = (0, _test.testdataDir)('restore');
+  const repoUrl = `local:${repoDir}`;
+  afterAll(() => {
+    _fs.default.rmdirSync(repoDir, {
+      recursive: true
+    });
+
+    _fs.default.rmdirSync(restoreDir, {
+      recursive: true
+    });
+  });
+  it('create repo', () => {
+    sut.prepareRepo(repoUrl, password);
+  });
+  it('push data', () => {
+    sut.backup(repoUrl, _Path.AbsPath.from(backupDir), _Path.RelativePath.from('.'), password);
+  });
+  it('restore data', () => {
+    sut.restore(repoUrl, _Path.AbsPath.from(restoreDir), password);
+    const res = (0, _dirCompare.compareSync)(backupDir, restoreDir);
+    expect(res.same).toBeTrue();
+  });
+});

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 setup ci to make tests work
+it.skip('works', () => {
+  const sut = new _Gpg.Gpg(new _Shell.Shell(new _AppLogger.AppLogger()));
+  const key = sut.exportKey('foo');
+  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;

package/lib/{shell → tools/shell}/shellCmd.js

@@ -10,12 +10,14 @@ var _child_process = require("child_process");
 const shellCmd = (cmd, {
   returnStdout,
   cwd,
-  stdin
+  stdin,
+  env
 } = {}) => {
   const res = (0, _child_process.execSync)(cmd, {
     cwd,
     input: stdin,
-    stdio: [stdin ? undefined : 'inherit', returnStdout ? undefined : 'inherit', 'inherit']
+    stdio: [stdin ? undefined : 'inherit', returnStdout ? undefined : 'inherit', 'inherit'],
+    env
   });
   if (returnStdout) return res.toString().trim();
   return null;

package/lib/tools/ssh/SshKeyManager.js

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SshKeyManager = void 0;
+
+var _Fs = require("../../fs/Fs");
+
+var _Path = require("../../fs/path/Path");
+
+var _os = _interopRequireDefault(require("os"));
+
+var _inversify = require("inversify");
+
+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; }
+
+let SshKeyManager = (_dec = (0, _inversify.injectable)(), _dec2 = Reflect.metadata("design:type", Function), _dec3 = Reflect.metadata("design:paramtypes", [typeof _Fs.Fs === "undefined" ? Object : _Fs.Fs]), _dec(_class = _dec2(_class = _dec3(_class = class SshKeyManager {
+  constructor(fs) {
+    this.fs = fs;
+
+    _defineProperty(this, "sshDir", void 0);
+
+    _defineProperty(this, "exportKey", id => {
+      return this.fs.readFile(this.sshDir);
+    });
+
+    this.sshDir = _Path.AbsPath.from(_os.default.homedir()).resolve('.ssh');
+  }
+
+}) || _class) || _class) || _class);
+exports.SshKeyManager = SshKeyManager;

package/lib/tools/ssh/SshKeyManager.spec.js

@@ -0,0 +1,14 @@
+"use strict";
+
+var _SshKeyManager = require("./SshKeyManager");
+
+var _Fs = require("../../fs/Fs");
+
+var _AppLogger = require("../../log/AppLogger");
+
+// TODO setup ci to make tests work
+it.skip('works', () => {
+  const sut = new _SshKeyManager.SshKeyManager(new _Fs.Fs(new _AppLogger.AppLogger()));
+  const key = sut.exportKey('id_rsa');
+  console.log('key', key);
+});

package/lib/types.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ps-aux/nodebup",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "",
   "module": "lib/index.js",
   "main": "lib/index.js",
@@ -8,11 +8,13 @@
     "build": "rm -rf build && babel --extensions '.ts,.js' src -d lib src",
     "pub": "npm publish --access public",
     "test": "jest",
-    "typecheck": "tsc --noEmit",
+    "tc": "tsc --noEmit",
     "format": "prettier \"**/*.{js,ts,tsx}\" --write",
     "build-n-run": "npm run build && ",
     "lint": "eslint '**/*.{js,ts,tsx}' --fix",
-    "update-deps": "ncu --upgrade"
+    "update-deps": "ncu --upgrade",
+    "prepare": "husky install",
+    "pre-commit": "lint-staged"
   },
   "keywords": [],
   "author": "",
@@ -25,58 +27,61 @@
   },
   "typings": "src/types.d.ts",
   "devDependencies": {
-    "@babel/cli": "^7.8.4",
-    "@babel/core": "^7.8.7",
-    "@babel/node": "^7.8.7",
-    "@babel/plugin-proposal-class-properties": "^7.8.3",
-    "@babel/plugin-proposal-object-rest-spread": "^7.8.3",
-    "@babel/plugin-proposal-optional-chaining": "^7.8.3",
-    "@babel/preset-env": "^7.8.7",
-    "@babel/preset-typescript": "^7.8.3",
-    "@types/jest": "^25.1.4",
-    "@types/jest-when": "^2.7.0",
-    "@types/node": "^13.9.0",
-    "@types/ramda": "^0.26.43",
-    "@typescript-eslint/eslint-plugin": "^2.23.0",
-    "@typescript-eslint/parser": "^2.23.0",
-    "babel-eslint": "^10.1.0",
-    "babel-jest": "^25.1.0",
-    "babel-plugin-module-resolver": "^4.0.0",
-    "eslint": "^6.8.0",
-    "eslint-config-standard": "^14.1.0",
-    "eslint-plugin-import": "^2.20.1",
-    "eslint-plugin-node": "^11.0.0",
-    "eslint-plugin-prettier": "^3.1.2",
-    "eslint-plugin-promise": "^4.2.1",
-    "eslint-plugin-standard": "^4.0.1",
-    "husky": "^4.2.3",
-    "jest": "^25.1.0",
-    "jest-when": "^2.7.0",
-    "lint-staged": "^10.0.8",
-    "npm-check-updates": "^4.0.4",
-    "prettier": "^1.19.1",
-    "typescript": "^3.8.3"
-  },
-  "husky": {
-    "hooks": {
-      "pre-commit": "lint-staged"
-    }
+    "@babel/cli": "^7.16.0",
+    "@babel/core": "^7.16.5",
+    "@babel/eslint-parser": "^7.16.5",
+    "@babel/node": "^7.16.5",
+    "@babel/plugin-proposal-class-properties": "^7.16.5",
+    "@babel/plugin-proposal-decorators": "^7.16.5",
+    "@babel/plugin-proposal-object-rest-spread": "^7.16.5",
+    "@babel/plugin-proposal-optional-chaining": "^7.16.5",
+    "@babel/preset-env": "^7.16.5",
+    "@babel/preset-typescript": "^7.16.5",
+    "@types/jest": "^27.0.3",
+    "@types/jest-when": "^2.7.4",
+    "@types/node": "^17.0.5",
+    "@types/ramda": "^0.27.62",
+    "@typescript-eslint/eslint-plugin": "^5.8.1",
+    "@typescript-eslint/parser": "^5.8.1",
+    "babel-plugin-module-resolver": "^4.1.0",
+    "babel-plugin-transform-typescript-metadata": "^0.3.2",
+    "dir-compare": "^4.0.0",
+    "eslint": "^8.5.0",
+    "eslint-config-standard": "^16.0.3",
+    "eslint-plugin-import": "^2.25.3",
+    "eslint-plugin-node": "^11.1.0",
+    "eslint-plugin-prettier": "^4.0.0",
+    "eslint-plugin-promise": "^6.0.0",
+    "eslint-plugin-standard": "^5.0.0",
+    "husky": "^7.0.4",
+    "jest": "^27.4.5",
+    "jest-extended": "^1.2.0",
+    "jest-when": "^3.5.0",
+    "lint-staged": "^12.1.4",
+    "npm-check-updates": "^12.0.5",
+    "prettier": "^2.5.1",
+    "ts-jest": "^27.1.2",
+    "typescript": "^4.5.4"
   },
   "lint-staged": {
     "./**/*.{js,ts,tsx}": [
       "prettier --write",
-      "eslint --fix",
-      "git add"
+      "eslint --fix"
     ]
   },
   "dependencies": {
     "@hapi/joi": "^17.1.1",
-    "@types/hapi__joi": "^16.0.12",
-    "axios": "^0.19.2",
-    "handlebars": "^4.7.3",
-    "js-yaml": "^3.13.1",
-    "ramda": "^0.27.0",
-    "wait-on": "^4.0.1",
-    "yargs": "^15.3.0"
+    "@ps-aux/nclif": "^0.0.6-alpha.2",
+    "@types/hapi__joi": "^17.1.8",
+    "axios": "^0.24.0",
+    "handlebars": "^4.7.7",
+    "inversify": "^6.0.1",
+    "js-yaml": "^4.1.0",
+    "pino": "^7.6.2",
+    "ramda": "^0.27.1",
+    "reflect-metadata": "^0.1.13",
+    "wait-on": "^6.0.0",
+    "yaml": "^1.10.2",
+    "yargs": "^17.3.1"
   }
 }

package/lib/cli/entrypoint.js

@@ -1,27 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-var _yargs = _interopRequireDefault(require("yargs"));
-
-var _foo = require("../foo/foo.command");
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-const entrypoint = ctx => {
-  try {
-    // eslint-disable-next-line no-unused-expressions
-    _yargs.default.scriptName('bup').usage('$0 <cmd> [args]').command((0, _foo.fooCmd)()).alias('h', 'help').help() // https://github.com/yargs/yargs/issues/895#issuecomment-392893305
-    .demandCommand().recommendCommands().strict().argv;
-  } catch (err) {
-    console.log(err);
-    console.error('Error:', err.message);
-    process.exit(1);
-  }
-};
-
-var _default = entrypoint;
-exports.default = _default;

package/lib/foo/foo.command.js

@@ -1,16 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.fooCmd = void 0;
-
-const fooCmd = () => ({
-  command: 'foo',
-  describe: 'Do foo',
-  handler: args => {
-    console.log('haha'); // throw new Error('Assertion error')
-  }
-});
-
-exports.fooCmd = fooCmd;

package/lib/shell/LocalShellCmdExecutor.js

@@ -1,46 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.LocalShellCmdExecutor = void 0;
-
-var _MinimalLogger = require("../log/MinimalLogger");
-
-var _shellCmd = require("./shellCmd");
-
-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 LocalShellCmdExecutor {
-  constructor(log) {
-    _defineProperty(this, "log", void 0);
-
-    _defineProperty(this, "exec", cmd => {
-      this.log.debug(cmd);
-      (0, _shellCmd.shellCmd)(cmd, {
-        returnStdout: false
-      });
-    });
-
-    _defineProperty(this, "execWithStdIn", (cmd, stdin) => {
-      this.log.debug(`"${stdin}" > ${cmd}`);
-      (0, _shellCmd.shellCmd)(cmd, {
-        stdin,
-        returnStdout: false
-      });
-    });
-
-    _defineProperty(this, "execAndReturnVal", (cmd, ops) => {
-      this.log.debug(cmd, '[stdout consumed]');
-      return (0, _shellCmd.shellCmd)(cmd, {
-        returnStdout: true,
-        ...ops
-      });
-    });
-
-    this.log = log || (0, _MinimalLogger.minimalLogger)();
-  }
-
-}
-
-exports.LocalShellCmdExecutor = LocalShellCmdExecutor;

package/lib/types.d.js

@@ -1 +0,0 @@
-"use strict";