@meedamian/savepass/index.js

'use strict';
var AVAILABLE_FIELDS, DEBUG, DEFAULT_CONFIG, OUTPUTS_DIR, TEMPLATES_DIR, async, chalk, cli, config, exec, f, filterTemplates, fs, getChoicesFrom, getConfig, getConfigPath, getFrom, getHomeDir, getOutputDir, getQuestionFor, inquirer, log, logJson, meow, path, readOwnConfig, readTemplates, templates, toJson;

inquirer = require('inquirer');

exec = require('child_process').exec;

async = require('async');

chalk = require('chalk');

meow = require('meow');

path = require('path');

fs = require('fs-extra');

DEBUG = false;

TEMPLATES_DIR = 'templates';

OUTPUTS_DIR = 'outputs';

DEFAULT_CONFIG = {
  path: OUTPUTS_DIR,
  extensions: '.enc.txt'
};

AVAILABLE_FIELDS = {
  name: {},
  website: {},
  login: {},
  password: {
    type: 'password'
  },
  email: {},
  seed: {
    msg: 'Input 2FA seed'
  }
};

log = (function(_this) {
  return function() {
    if (DEBUG) {
      return console.log.apply(_this, arguments);
    }
  };
})(this);

toJson = function(obj) {
  return JSON.stringify(obj, null, '  ');
};

logJson = function(obj) {
  return log(toJson(obj));
};

getHomeDir = function() {
  return process.env.HOME || process.env.USERPROFILE;
};

getConfigPath = function(name) {
  if (name == null) {
    name = 'savepass';
  }
  return path.join(getHomeDir(), "/.config/" + name + "/config.json");
};

getOutputDir = function() {
  return path.resolve(!config.path ? OUTPUTS_DIR : config.path.replace(/^~/, getHomeDir()));
};

getQuestionFor = function(fieldType) {
  var base, ref, ref1;
  base = AVAILABLE_FIELDS[fieldType];
  return {
    type: (ref = base.type) != null ? ref : 'input',
    name: fieldType,
    message: (ref1 = base.msg) != null ? ref1 : 'Input your ' + fieldType
  };
};

getChoicesFrom = function(templates) {
  return templates.map(function(v, i) {
    return {
      name: v.name,
      value: i
    };
  });
};

getFrom = function(templates) {
  return function(i) {
    return templates[i];
  };
};

getConfig = function(name, cb) {
  var ref;
  if (name == null) {
    name = 'keybase';
  }
  if (typeof name === 'function') {
    ref = ['savepass', name], name = ref[0], cb = ref[1];
  } else if (name === 'self') {
    name = 'savepass';
  }
  return fs.readJson(getConfigPath(name), cb);
};

config = {};

readOwnConfig = function(next) {
  return getConfig(function(err, data) {
    if (err && err.code === 'ENOENT') {
      log('creating config file...');
      config = DEFAULT_CONFIG;
      log('config (new):', toJson(config));
      return fs.outputJson(err.path, config, next);
    } else {
      config = data;
      log('config (file):', toJson(config));
      return next();
    }
  });
};

templates = [];

filterTemplates = function(filter) {
  return templates.filter(function(t) {
    return -1 < t.fileName.indexOf(filter);
  });
};

readTemplates = function(next) {
  var readTemplate;
  readTemplate = function(template, next) {
    var tempPath;
    tempPath = path.resolve(TEMPLATES_DIR, template);
    return fs.readFile(tempPath, {
      encoding: 'utf8'
    }, function(err, fileContent) {
      var af, m, re;
      if (err) {
        next(err);
        return;
      }
      re = new RegExp('<(' + ((function() {
        var results;
        results = [];
        for (af in AVAILABLE_FIELDS) {
          results.push(af);
        }
        return results;
      })()).join('|') + ')>', 'g');
      templates.push({
        file: tempPath,
        fileName: template,
        fileContent: fileContent,
        fields: (function() {
          var results;
          results = [];
          while (m = re.exec(fileContent)) {
            results.push(m[1]);
          }
          return results;
        })(),
        name: template.replace(/\.temp$/, '').replace(/-/g, ' ').split(' ').map(function(word) {
          return word.charAt(0).toUpperCase() + word.substr(1);
        }).join(' ')
      });
      return next();
    });
  };
  return fs.readdir(TEMPLATES_DIR, function(err, files) {
    if (err) {
      console.error('not even directory for templates exist.', toJson(err));
      return;
    }
    return async.each(files, readTemplate, function(err) {
      if (err) {
        console.error('reading template file failed... apparently', err);
        return;
      }
      log(templates.length + " templates read:", templates.map(function(t) {
        return t.fileName;
      }));
      return next();
    });
  });
};

cli = meow({
  help: [
    'Usage: ' + chalk.bold('savepass <command>'), '', 'where <command> is one of:', '    add, new, list, ls,', '    remove*, rm*, get*', '', 'Example Usage:', '    savepass add [OPTIONAL <flags>]', '    savepass ls', '', 'Available ' + chalk.bold('add|new') + ' subcomand flags:', '    ' + chalk.bold('--template') + '=<templateName>', '        Specify template name to be used. Available templates can be', '        found in `templates/` folder.', '    ' + chalk.bold('--keybase-user') + '=<keybaseUsername>', '        Encrypt output file for a different user then the one logged in.', '    ' + ((function() {
      var results;
      results = [];
      for (f in AVAILABLE_FIELDS) {
        results.push(chalk.bold("--" + f));
      }
      return results;
    })()).join(', '), '        Using those flags you can pass values, to be filled into a', '        template, directly from CLI. All flags accept strings or "null" to disable.', '        ' + chalk.bold('Flag --password can only be set to null'), '', 'Specify configs in the json-formatted file:', '    ' + getConfigPath()
  ].join('\n')
});

log('cli flags:', cli.input, toJson(cli.flags));

async.parallel([readTemplates, readOwnConfig], function(err) {
  var matchingTemplates, step1, step2, step3, step4, step5, step6;
  if (err) {
    console.error(err);
    return;
  }
  switch (cli.input[0]) {
    case 'add':
    case 'new':
    case void 0:
      step6 = function(path, content) {
        console.log('saving...');
        return fs.outputFile(path, content, function(err) {
          if (err) {
            return console.error(err);
          }
          return console.log('success!');
        });
      };
      step5 = function(fileName, contents) {
        var filePath, q, qs;
        log('file name:', fileName);
        q = {
          name: 'fileName',
          message: 'How do you want to name the file?'
        };
        if (fileName) {
          q["default"] = fileName.replace('.', '-');
        }
        filePath = null;
        qs = [
          q, {
            name: 'confirm',
            type: 'confirm',
            message: function(prevAnswer) {
              var outputDir;
              outputDir = getOutputDir();
              log('Output files dir:', outputDir);
              filePath = path.resolve(outputDir, prevAnswer.fileName + (config.extensions || DEFAULT_CONFIG.extensions));
              return ['File will be saved as:', ' ' + filePath].join('\n');
            }
          }
        ];
        return inquirer.prompt(qs, function(answers) {
          if (!answers.confirm) {
            step5(answers.fileName, contents);
            return;
          }
          return step6(filePath, contents);
        });
      };
      step4 = function(name, text) {
        var getKeybaseUser;
        getKeybaseUser = function(cb) {
          if (cli.flags.keybaseUser) {
            cb(cli.flags.keybaseUser);
            return;
          }
          return getConfig('keybase', function(err, data) {
            return cb(data.user.name);
          });
        };
        return getKeybaseUser(function(keybaseUser) {
          console.log("Encrypting and signing for: " + keybaseUser);
          return exec(['keybase encrypt', '-s', "-m '" + text + "'", keybaseUser].join(' '), function(err, stdout, stderr) {
            if (err || stderr) {
              if (err) {
                console.error(err);
              }
              if (stderr) {
                console.error(stderr);
              }
              return;
            }
            log('encrypted file:\n', stdout);
            return step5(name, stdout);
          });
        });
      };
      step3 = function(template, data) {
        var key, val;
        log('Template and data before merge:\n', template, toJson(data));
        for (key in data) {
          val = data[key];
          template = template.replace("<" + key + ">", val != null ? val : '');
        }
        return inquirer.prompt({
          type: 'confirm',
          name: 'proceed',
          message: ['The following content will be encrypted and saved:', '', template, 'Do you want to proceed?'].join('\n')
        }, function(answers) {
          if (answers.proceed) {
            return step4(data.website, template);
          }
        });
      };
      step2 = function(chosenTemplate) {
        var encryptables, field, j, len, questions, ref, ref1, ref2;
        log('chosen template:', toJson(chosenTemplate));
        questions = [getQuestionFor('password')];
        encryptables = {
          password: null
        };
        ref = chosenTemplate.fields;
        for (j = 0, len = ref.length; j < len; j++) {
          field = ref[j];
          if (!(field !== 'password')) {
            continue;
          }
          encryptables[field] = (ref1 = cli.flags[field]) != null ? ref1 : null;
          if (!encryptables[field]) {
            questions.push(getQuestionFor(field));
          } else if ((ref2 = encryptables[field]) === 'null' || ref2 === 'false') {
            encryptables[field] = null;
          }
        }
        log('encryptables (CLI)', toJson(encryptables));
        log('questions', toJson(questions));
        return inquirer.prompt(questions, function(answers) {
          var a;
          log('answers', toJson(answers));
          for (a in encryptables) {
            if (answers[a] && answers[a] !== '') {
              encryptables[a] = answers[a];
            }
          }
          log('encryptables (ALL)', toJson(encryptables));
          return step3(chosenTemplate.fileContent, encryptables);
        });
      };
      step1 = function(templates) {
        return inquirer.prompt({
          type: 'list',
          name: 'type',
          message: 'Which template do you want to use?',
          choices: getChoicesFrom(templates),
          filter: getFrom(templates)
        }, function(answer) {
          return step2(answer.type);
        });
      };
      matchingTemplates = filterTemplates(cli.flags.template);
      switch (matchingTemplates.length) {
        case 0:
          return step1(templates);
        case 1:
          return step2(matchingTemplates[0]);
        default:
          return step1(matchingTemplates);
      }
      break;
    case 'list':
    case 'ls':
      log('ls');
      return fs.readdir(getOutputDir(), function(err, files) {
        var fileList;
        if (err) {
          console.error(err);
          return;
        }
        fileList = files.filter(function(fileName) {
          return /\.enc\.txt$/.test(fileName);
        }).map(function(fileName) {
          return ['', chalk.green('*'), chalk.bold(fileName.replace(/\.enc\.txt$/, '').replace(/[-_]/g, ' ')), chalk.dim(" (" + fileName + ")")].join(' ');
        }).join('\n');
        console.log("Your encrypted files: (from " + (chalk.bold(getOutputDir())) + ")\n");
        return console.log(fileList);
      });
  }
});


/*

 file
 login
 email
 password
 website
 2FA
 rule (desc)
 just password(s)

 creds|credentials
 one
 many|multi
 file
 desc
 */