r8s-cli/dist/utils/ssh.js

A command line tool for Reaction Commerce to be used with kubernetes

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.ensureSSHKeysExist = undefined;

var _filter2 = require('lodash/filter');

var _filter3 = _interopRequireDefault(_filter2);

/**
 * Check if the user has a registered SSH key in ~/.reaction/keys/
 * @return {undefined} returns nothing
 */
var ensureSSHKeysExist = exports.ensureSSHKeysExist = function () {
  var _ref2 = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee() {
    var keys, homeDir, hasKey, email, keyPair;
    return regeneratorRuntime.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            _context.next = 2;
            return (0, _list2.default)();

          case 2:
            keys = _context.sent;
            homeDir = _os2.default.homedir();
            hasKey = false;


            keys.forEach(function (k) {
              if ((0, _fs.exists)(homeDir + '/.reaction/keys/' + k.title)) {
                hasKey = true;
              }
            });

            if (!(keys.length === 0 || !hasKey)) {
              _context.next = 11;
              break;
            }

            email = Config.get('global', 'launchdock.email');
            keyPair = generateKeyPair({ email: email });
            _context.next = 11;
            return (0, _add2.default)({ publicKey: keyPair.publicKey, title: keyPair.title });

          case 11:
          case 'end':
            return _context.stop();
        }
      }
    }, _callee, this);
  }));

  return function ensureSSHKeysExist() {
    return _ref2.apply(this, arguments);
  };
}();

exports.generateKeyPair = generateKeyPair;
exports.setGitSSHKeyEnv = setGitSSHKeyEnv;

var _fsExtra = require('fs-extra');

var _fsExtra2 = _interopRequireDefault(_fsExtra);

var _path = require('path');

var _path2 = _interopRequireDefault(_path);

var _os = require('os');

var _os2 = _interopRequireDefault(_os);

var _keypair = require('keypair');

var _keypair2 = _interopRequireDefault(_keypair);

var _nodeForge = require('node-forge');

var _uuid = require('uuid');

var _uuid2 = _interopRequireDefault(_uuid);

var _config = require('./config');

var Config = _interopRequireWildcard(_config);

var _fs = require('./fs');

var _logger = require('./logger');

var _logger2 = _interopRequireDefault(_logger);

var _list = require('../commands/keys/list');

var _list2 = _interopRequireDefault(_list);

var _add = require('../commands/keys/add');

var _add2 = _interopRequireDefault(_add);

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; }

/**
 * Generate an SSH key pair and save them at ~/.reaction/keys/
 * @param  {String} email  The email found in the public key
 * @return {Object}  returns a results object: { publicKey: String, privateKey: String, title: String }
 */
function generateKeyPair(_ref) {
  var email = _ref.email;

  if (!email) {
    _logger2.default.error('An email is required to generate a keypair');
    process.exit(1);
  }

  var pair = (0, _keypair2.default)();
  var pub = _nodeForge.pki.publicKeyFromPem(pair.public);
  var priv = _nodeForge.pki.privateKeyFromPem(pair.private);

  var publicKey = _nodeForge.ssh.publicKeyToOpenSSH(pub, email);
  var privateKey = _nodeForge.ssh.privateKeyToOpenSSH(priv);

  var userHome = _os2.default.homedir();
  var title = _uuid2.default.v1();

  var publicKeyFile = _path2.default.resolve(userHome + '/.reaction/keys/' + title + '.pub');
  var privateKeyFile = _path2.default.resolve(userHome + '/.reaction/keys/' + title);

  _fsExtra2.default.ensureFileSync(publicKeyFile);
  _fsExtra2.default.ensureFileSync(privateKeyFile);

  _fsExtra2.default.writeFileSync(publicKeyFile, publicKey);
  _fsExtra2.default.writeFileSync(privateKeyFile, privateKey);

  _fsExtra2.default.chmodSync(publicKeyFile, '400');
  _fsExtra2.default.chmodSync(privateKeyFile, '400');

  _logger2.default.debug('Generated new SSH key pair: ' + title);

  return {
    publicKey: publicKey,
    privateKey: privateKey,
    title: title
  };
}

/**
 * Check if the user has a registered SSH key in ~/.reaction/keys/
 * If so, set the GIT_SSH_COMMAND environment variable to use the private key's identity
 * https://superuser.com/a/912281
 * @return {String|null} returns the path to the chosen private key or null if none found
 */
function setGitSSHKeyEnv() {
  var homeDir = _os2.default.homedir();
  var keys = Config.get('global', 'launchdock.keys', []);
  var key = (0, _filter3.default)(keys, function (k) {
    return (0, _fs.exists)(_path2.default.resolve(homeDir + '/.reaction/keys/' + k.title));
  })[0];

  if (!!key) {
    var keyPath = _path2.default.resolve(homeDir + '/.reaction/keys/' + key.title);
    process.env.GIT_SSH_COMMAND = 'ssh -i ' + keyPath;
    _logger2.default.debug('Setting SSH key identity to: ' + keyPath);
    _logger2.default.debug('export GIT_SSH_COMMAND=' + process.env.GIT_SSH_COMMAND);
    return keyPath;
  }

  return null;
}