git-off

git-off (50220B)

---

 #! /usr/bin/env node
 /*
  * CODE
  *
  * modules
  * defaults
  * helpers
  * core
  * main
  *
  *
  * modules
  *   all dependencies
  *
  * defaults
  *   objInfo fields:  for indexing cat-diff response in push command
  *   externalHelpers: shell commands to be used with the exec function
  *   runtimeConfig:   config built by offHelpers
  *   offDEFAULTS:     default configuration for first time install
  *
  * helpers
  *   expandHome:      expands ~/
  *   gitConfig:       handles global git config
  *   offLog:          appends log to git config off.log
  *   offLogRepo:      log for commands run in git repo
  *   exec:            runs an externalHelpers with parameters
  *   mkdirParents:    recursive mkdir
  *   rmAll:           delete recursively files and directories
  *   copy:            copies files
  *   offHelpers:      git-off helpers
  *
  * core
  *   transport:       transport functions for git off store
  *   offCommands:     command line functions
  *
  * main
  *   parse CLI arguments
  */
 
 /*
  * modules
  */
 var COMMAND_MAP, StringDecoder, copy, exec, expandHome, externalHelpers, fs, fssync, gitConfig, mkdirParents, mkdirp, offCommands, offDEFAULTS, offHelpers, offLog, offLogRepo, oiNAME, oiOID, oiPERMISSIONS, oiPREVIOUSOID, oiPREVIOUSPERMISSIONS, path, readline, rimraf, rmAll, runtimeConfig, showCommandHelp, syncexec, thisrepo, transport, walkSync;
 
 require('colors');
 
 fs = require('fs');
 
 path = require('path');
 
 fssync = require('fs-sync');
 
 syncexec = require('sync-exec');
 
 mkdirp = require('mkdirp');
 
 rimraf = require('rimraf');
 
 readline = require('readline');
 
 StringDecoder = require('string_decoder').StringDecoder;
 
 
 /*
  * defaults
  */
 
 oiPREVIOUSPERMISSIONS = 0;
 
 oiPERMISSIONS = 1;
 
 oiPREVIOUSOID = 2;
 
 oiOID = 3;
 
 oiNAME = 4;
 
 externalHelpers = {
   'gitConfigGlobal': 'git config --global',
   'gitConfig': 'git config',
   'gitRepoRoot': 'git rev-parse --show-toplevel',
   'gitList': 'git rev-list',
   'gitListEmptyRemote': 'git rev-list --max-parents=0',
   'gitDiff': 'git show --raw --format="" --no-abbrev',
   'gitCat': 'git cat-file -p',
   'sha': 'git hash-object --no-filters',
   'listAttr': 'git check-attr -a',
   'ssh': 'ssh',
   'scp': 'scp',
   'curl': 'curl',
   'mv': 'mv',
   'rsync': 'rsync'
 };
 
 runtimeConfig = {
   'currentRepoRoot': '',
   'objectPath': '',
   'offStore': '',
   'offHttp': '',
   'offMode': '',
   'offIntegrity': '',
   'offScp': '',
   'offScpUser': '',
   'offPem': '',
   'offSshOptions': '',
   'offScpOptions': '',
   'offRsyncOptions': '',
   'offCurlOptions': '',
   'log': '',
   'offConfigAlways': '',
   's3Region': '',
   's3Bucket': '',
   'transform': '',
   'transformTo': '',
   'transformFrom': ''
 };
 
 offDEFAULTS = {
   'objectPath': '/.git/off/objects',
   'mode': 'copy',
   'integrity': 'disable',
   'pem': 'offNoValue',
   'scpHost': 'offNoValue',
   'scpUser': '',
   'sshOptions': '-C -o StrictHostKeyChecking=no -o ConnectTimeout=3',
   'scpOptions': '-C -o StrictHostKeyChecking=no -o ConnectTimeout=3 -p',
   'rsyncOptions': '-az -e \'ssh -i _i\'',
   'store': '~/.git-off/offStore',
   'http': 'offNoValue',
   'curlOptions': '-o',
   'log': '~/.git-off/log',
   'configAlways': 'offNoValue',
   's3Region': 'offNoValue',
   's3Bucket': 'offNoValue',
   'transform': 'disable',
   'transformTo': 'pbzip2 -9 -c _1 > _2',
   'transformFrom': 'pbzip2 -d -c _1 > _2',
   'prePush': '#!/bin/sh\ncommand -v git-off >/dev/null 2>&1 || { echo >&2 "\\nThis repository is configured for Git off but \'git-off\' was not found on your path. If you no longer wish to use git off, remove this hook by deleting .git/hooks/pre-push.\\n"; exit 2; }\ngit off pre-push "$@"',
   'offSignature': '### git-off v1 sha:',
   'shaLength': 40
 };
 
 
 /*
  * helpers
  */
 
 expandHome = function(p) {
   if (p.slice(0, 2) === '~/') {
     p = process.env.HOME + '/' + p.slice(2);
   }
   return p;
 };
 
 gitConfig = {
   'set': function(key, value) {
     exec('gitConfig', ['--global', key, '"' + value + '"']);
   },
   'setLocal': function(key, value) {
     exec('gitConfig', [key, '"' + value + '"']);
   },
   'setThisRepo': function(key, value) {
     exec('gitConfig', ['--file ' + offHelpers.gitRepoRoot() + '/.git-off', key, '"' + value + '"']);
   },
   'get': function(key) {
     var r;
     if (offHelpers.offConfigAlways() === 'GIT_OFF_CONFIG') {
       r = '';
       if (process.env.GIT_OFF_CONFIG !== void 0 && fs.existsSync(process.env.GIT_OFF_CONFIG) === true) {
         r = exec('gitConfig', ['--file ' + process.env.GIT_OFF_CONFIG, key]).stdout.trim();
       }
       return r;
     }
     if (offHelpers.offConfigAlways() === 'repo') {
       r = '';
       if (fs.existsSync(offHelpers.gitRepoRoot(true) + '/.git-off') === true) {
         r = exec('gitConfig', ['--file ' + offHelpers.gitRepoRoot() + '/.git-off', key]).stdout.trim();
       }
       return r;
     }
     if (offHelpers.offConfigAlways() === 'global') {
       return exec('gitConfig', [key]).stdout.trim();
     }
     if (process.env.GIT_OFF_CONFIG !== void 0 && fs.existsSync(process.env.GIT_OFF_CONFIG) === true) {
       r = exec('gitConfig', ['--file ' + process.env.GIT_OFF_CONFIG, key]).stdout.trim();
       if (r !== '') {
         return r;
       }
     }
     if (fs.existsSync(offHelpers.gitRepoRoot(true) + '/.git-off') === true) {
       r = exec('gitConfig', ['--file ' + offHelpers.gitRepoRoot() + '/.git-off', key]).stdout.trim();
       if (r !== '') {
         return r;
       }
     }
     return exec('gitConfig', [key]).stdout.trim();
   },
   'getSyncexec': function(key) {
     return syncexec(externalHelpers.gitConfig + ' ' + key);
   }
 };
 
 mkdirParents = function(p) {
   p = expandHome(p);
   mkdirp.sync(p, function(err) {
     console.error(err);
   });
 };
 
 rmAll = function(p) {
   p = expandHome(p);
   rimraf.sync(p);
 };
 
 offLog = function(s) {
   var r;
   if (runtimeConfig.log === '') {
     r = gitConfig.getSyncexec('off.log');
     runtimeConfig.log = expandHome(r.stdout.trim());
     if (runtimeConfig.log === '') {
       console.error('Missing off.log config. Run "git config --global off.log ~/.git-off/log".'.red.bold);
       process.exit(1);
     }
   }
   if (fs.existsSync(path.dirname(runtimeConfig.log)) === false) {
     mkdirParents(path.dirname(runtimeConfig.log));
   }
   fs.appendFileSync(runtimeConfig.log, s + '\n');
 };
 
 offLogRepo = function(s) {
   offLog('REPO path: ' + offHelpers.gitRepoRoot() + ' ' + s);
 };
 
 exec = function(cmdName, paramsArray, ignoreStderr) {
   var r;
   if (paramsArray == null) {
     paramsArray = [];
   }
   if (ignoreStderr == null) {
     ignoreStderr = false;
   }
   r = syncexec(externalHelpers[cmdName] + ' ' + paramsArray.join(' '));
   if (r.stderr !== '' && ignoreStderr === false) {
     console.error(r.stderr.red.bold);
     offLog(r.stderr.red.bold);
     process.exit(1);
   }
   return r;
 };
 
 copy = function(src, dst) {
   fssync.copy(src, dst);
 };
 
 walkSync = function(dir, filelist) {
   var files;
   if (filelist == null) {
     filelist = [];
   }
   files = fs.readdirSync(dir);
   files.forEach(function(file) {
     if (fs.statSync(dir + '/' + file).isDirectory()) {
       filelist = walkSync(dir + '/' + file, filelist);
     } else {
       filelist.push(dir + '/' + file);
     }
   });
   return filelist;
 };
 
 offHelpers = {
   'gitRepoRoot': function(ignoreStderr) {
     var r;
     if (ignoreStderr == null) {
       ignoreStderr = false;
     }
     if (runtimeConfig.currentRepoRoot === '') {
       r = exec('gitRepoRoot', [], ignoreStderr);
       runtimeConfig.currentRepoRoot = r.stdout.trim();
     }
     return runtimeConfig.currentRepoRoot;
   },
   'objectPath': function() {
     if (runtimeConfig.objectPath === '') {
       runtimeConfig.objectPath = this.gitRepoRoot() + offDEFAULTS.objectPath;
     }
     return runtimeConfig.objectPath;
   },
   'offStore': function() {
     var r;
     if (runtimeConfig.offStore === '') {
       r = gitConfig.get('off.store');
       runtimeConfig.offStore = expandHome(r);
     }
     return runtimeConfig.offStore;
   },
   'offHttp': function() {
     if (runtimeConfig.offHttp === '') {
       runtimeConfig.offHttp = gitConfig.get('off.http');
     }
     return runtimeConfig.offHttp;
   },
   'offCurlOptions': function() {
     if (runtimeConfig.offCurlOptions === '') {
       runtimeConfig.offCurlOptions = gitConfig.get('off.curloptions');
     }
     return runtimeConfig.offCurlOptions;
   },
   'offMode': function() {
     if (runtimeConfig.offMode === '') {
       runtimeConfig.offMode = gitConfig.get('off.mode');
     }
     return runtimeConfig.offMode;
   },
   'offIntegrity': function() {
     if (runtimeConfig.offIntegrity === '') {
       runtimeConfig.offIntegrity = gitConfig.get('off.integrity');
     }
     return runtimeConfig.offIntegrity;
   },
   'offPem': function() {
     var r;
     if (runtimeConfig.offPem === '') {
       r = gitConfig.get('off.pem');
       runtimeConfig.offPem = expandHome(r);
     }
     return runtimeConfig.offPem;
   },
   'offSshOptions': function() {
     if (runtimeConfig.offSshOptions === '') {
       runtimeConfig.offSshOptions = gitConfig.get('off.sshoptions');
     }
     return runtimeConfig.offSshOptions;
   },
   'offScpOptions': function() {
     if (runtimeConfig.offScpOptions === '') {
       runtimeConfig.offScpOptions = gitConfig.get('off.scpoptions');
     }
     return runtimeConfig.offScpOptions;
   },
   'offRsyncOptions': function() {
     if (runtimeConfig.offRsyncOptions === '') {
       runtimeConfig.offRsyncOptions = gitConfig.get('off.rsyncoptions');
     }
     return runtimeConfig.offRsyncOptions;
   },
   'offScp': function() {
     if (runtimeConfig.offScp === '') {
       runtimeConfig.offScp = gitConfig.get('off.scphost');
     }
     return runtimeConfig.offScp;
   },
   'offScpUser': function() {
     if (runtimeConfig.offScpUser === '') {
       runtimeConfig.offScpUser = gitConfig.get('off.scpuser');
     }
     return runtimeConfig.offScpUser;
   },
   'log': function() {
     var r;
     if (runtimeConfig.log === '') {
       r = gitConfig.getSyncexec('off.log');
       runtimeConfig.log = expandHome(r.stdout.trim());
     }
     return runtimeConfig.log;
   },
   'getLog': function() {
     offHelpers.log();
     if (runtimeConfig.log === '') {
       console.error('Missing off.log config. Run "git config --global off.log ~/.git-off/log".'.red.bold);
       process.exit(1);
     }
     return runtimeConfig.log;
   },
   'offConfigAlways': function() {
     var r;
     if (runtimeConfig.offConfigAlways === '') {
       r = gitConfig.getSyncexec('off.configAlways');
       runtimeConfig.offConfigAlways = r.stdout.trim();
     }
     return runtimeConfig.offConfigAlways;
   },
   's3Region': function() {
     if (runtimeConfig.s3Region === '') {
       runtimeConfig.s3Region = gitConfig.get('off.s3region');
     }
     return runtimeConfig.s3Region;
   },
   's3Bucket': function() {
     if (runtimeConfig.s3Bucket === '') {
       runtimeConfig.s3Bucket = gitConfig.get('off.s3bucket');
     }
     return runtimeConfig.s3Bucket;
   },
   'transform': function() {
     if (runtimeConfig.transform === '') {
       runtimeConfig.transform = gitConfig.get('off.transform');
     }
     return runtimeConfig.transform;
   },
   'transformTo': function() {
     if (runtimeConfig.transformTo === '') {
       runtimeConfig.transformTo = gitConfig.get('off.transformTo');
     }
     return runtimeConfig.transformTo;
   },
   'transformFrom': function() {
     if (runtimeConfig.transformFrom === '') {
       runtimeConfig.transformFrom = gitConfig.get('off.transformFrom');
     }
     return runtimeConfig.transformFrom;
   },
   'userAt': function() {
     var user;
     if (offHelpers.offScpUser() !== '') {
       user = offHelpers.offScpUser() + '@';
     } else {
       user = '';
     }
     return user;
   },
   'getSSHConfig': function() {
     var h_l, host, port, portAndPath_l, storePath, user;
     user = offHelpers.userAt();
     h_l = offHelpers.offScp().split(':');
     if (h_l[1] === void 0) {
       port = NaN;
     } else {
       portAndPath_l = h_l[1].split('/');
       port = parseInt(portAndPath_l[0]);
     }
     if (isNaN(port)) {
       host = h_l[0];
       storePath = h_l[1];
     } else {
       host = h_l[0];
       storePath = '/' + portAndPath_l.slice(1).join('/');
     }
     return [user + host, storePath, port];
   },
   'mkdirStore': function(p) {
     var h_l, pem, sshCmd;
     h_l = offHelpers.getSSHConfig();
     sshCmd = '"mkdir -p ' + h_l[1] + '/' + p;
     sshCmd += '"';
     if (offHelpers.offPem() === '' || offHelpers.offPem() === 'offNoValue') {
       pem = '';
     } else {
       pem = '-i ' + offHelpers.offPem();
     }
     if (isNaN(h_l[2])) {
       exec('ssh', [offHelpers.offSshOptions(), pem, h_l[0], sshCmd], true);
     } else {
       exec('ssh', [offHelpers.offSshOptions(), pem, '-p ' + h_l[2], h_l[0], sshCmd], true);
     }
   },
   'rmAllStore': function(p) {
     var h_l, pem, sshCmd;
     if (offHelpers.offPem() === '' || offHelpers.offPem() === 'offNoValue') {
       pem = '';
     } else {
       pem = '-i ' + offHelpers.offPem();
     }
     h_l = offHelpers.getSSHConfig();
     sshCmd = '"rm -rf ' + h_l[1] + '/' + p;
     sshCmd += '"';
     if (isNaN(h_l[2])) {
       exec('ssh', [offHelpers.offSshOptions(), pem, h_l[0], sshCmd], true);
     } else {
       exec('ssh', [offHelpers.offSshOptions(), pem, '-p ' + h_l[2], h_l[0], sshCmd], true);
     }
   },
   'copyTo': function() {
     var f, files, i, j, len1, len2, tfiles;
     tfiles = walkSync(offHelpers.objectPath());
     files = [];
     for (i = 0, len1 = tfiles.length; i < len1; i++) {
       f = tfiles[i];
       files.push(f.replace(offHelpers.objectPath() + '/', ''));
     }
     for (j = 0, len2 = files.length; j < len2; j++) {
       f = files[j];
       transport.send(f);
     }
   },
   'checkIntegrity': function(p) {
     var r, receivedSha, result;
     result = true;
     if (offHelpers.offIntegrity() === 'disable') {
       return true;
     }
     r = exec('sha', [p]);
     receivedSha = r.stdout.split(' ')[0].trim();
     if (path.basename(p) !== receivedSha) {
       console.log('git-off: The file ' + p + ' differs from the one that was pushed.');
       result = false;
     }
     return result;
   },
   'setTransport': function(mode) {
     if (mode == null) {
       mode = 'config';
     }
     if (mode === 'config') {
       mode = offHelpers.offMode();
     }
     if (mode === 'copy') {
       transport['send'] = function(file) {
         var f_l;
         f_l = file.split('/');
         if (fs.existsSync(offHelpers.offStore() + '/' + f_l[0] + '/' + f_l[1]) === false) {
           mkdirParents(offHelpers.offStore() + '/' + f_l[0] + '/' + f_l[1]);
         }
         copy(offHelpers.objectPath() + '/' + file, offHelpers.offStore() + '/' + file);
         fs.chmodSync(offHelpers.offStore() + '/' + file, '444');
       };
       transport['receive'] = function(file) {
         var f_l, readStream;
         if (offHelpers.transform() === 'enable' && offHelpers.transformFrom() !== '') {
           f_l = file.split('/');
           if (fs.existsSync(offHelpers.objectPath() + '/' + f_l[0] + '/' + f_l[1]) === false) {
             mkdirParents(offHelpers.objectPath() + '/' + f_l[0] + '/' + f_l[1]);
           }
           copy(offHelpers.offStore() + '/' + file, offHelpers.objectPath() + '/' + file);
           transport['transformFrom'](file);
           if (offHelpers.checkIntegrity(offHelpers.objectPath() + '/../tmp/' + file)) {
             readStream = fs.createReadStream(offHelpers.objectPath() + '/../tmp/' + file);
             readStream.pipe(process.stdout);
           }
         } else {
           if (offHelpers.checkIntegrity(offHelpers.offStore() + '/' + file)) {
             readStream = fs.createReadStream(offHelpers.offStore() + '/' + file);
             readStream.pipe(process.stdout);
           }
         }
       };
     } else if (mode === 'rsync') {
       transport['send'] = function(file) {
         var f_l, options;
         f_l = file.split('/');
         offHelpers.mkdirStore(f_l[0] + '/' + f_l[1]);
         options = offHelpers.offRsyncOptions();
         if (options.indexOf('_i') !== -1) {
           if (offHelpers.offPem() !== '' && offHelpers.offPem() !== 'offNoValue') {
             options = options.replace('_i', offHelpers.offPem());
           }
         }
         exec('rsync', [options, offHelpers.objectPath() + '/' + file, offHelpers.offScp() + '/' + file]);
       };
       transport['receive'] = function(file) {
         var f_l, options, readStream;
         f_l = file.split('/');
         if (fs.existsSync(offHelpers.objectPath() + '/' + f_l[0] + '/' + f_l[1]) === false) {
           mkdirParents(offHelpers.objectPath() + '/' + f_l[0] + '/' + f_l[1]);
         }
         options = offHelpers.offRsyncOptions();
         if (options.indexOf('_i') !== -1) {
           if (offHelpers.offPem() !== '' && offHelpers.offPem() !== 'offNoValue') {
             options = options.replace('_i', offHelpers.offPem());
           }
         }
         exec('rsync', [options, offHelpers.offScp() + '/' + file, offHelpers.objectPath() + '/' + file]);
         if (offHelpers.transform() === 'enable' && offHelpers.transformFrom() !== '') {
           transport['transformFrom'](file);
           if (offHelpers.checkIntegrity(offHelpers.objectPath() + '/../tmp/' + file)) {
             readStream = fs.createReadStream(offHelpers.objectPath() + '/../tmp/' + file);
             readStream.pipe(process.stdout);
           }
         } else {
           if (offHelpers.checkIntegrity(offHelpers.objectPath() + '/' + file)) {
             readStream = fs.createReadStream(offHelpers.objectPath() + '/' + file);
             readStream.pipe(process.stdout);
           }
         }
       };
     } else if (mode === 'scp') {
       transport['send'] = function(file) {
         var f_l, h_l, pem;
         f_l = file.split('/');
         offHelpers.mkdirStore(f_l[0] + '/' + f_l[1]);
         if (offHelpers.offPem() === '' || offHelpers.offPem() === 'offNoValue') {
           pem = '';
         } else {
           pem = '-i ' + offHelpers.offPem();
         }
         h_l = offHelpers.getSSHConfig();
         if (isNaN(h_l[2])) {
           exec('scp', [offHelpers.offScpOptions(), pem, offHelpers.objectPath() + '/' + file, h_l[0] + ':' + h_l[1] + '/' + file]);
         } else {
           exec('scp', [offHelpers.offScpOptions(), pem, '-P ' + h_l[2], offHelpers.objectPath() + '/' + file, h_l[0] + ':' + h_l[1] + '/' + file]);
         }
       };
       transport['receive'] = function(file) {
         var f_l, h_l, pem, readStream;
         f_l = file.split('/');
         if (fs.existsSync(offHelpers.objectPath() + '/' + f_l[0] + '/' + f_l[1]) === false) {
           mkdirParents(offHelpers.objectPath() + '/' + f_l[0] + '/' + f_l[1]);
         }
         if (offHelpers.offPem() === '' || offHelpers.offPem() === 'offNoValue') {
           pem = '';
         } else {
           pem = '-i ' + offHelpers.offPem();
         }
         h_l = offHelpers.getSSHConfig();
         if (isNaN(h_l[2])) {
           exec('scp', [offHelpers.offScpOptions(), pem, h_l[0] + ':' + h_l[1] + '/' + file, offHelpers.objectPath() + '/' + file]);
         } else {
           exec('scp', [offHelpers.offScpOptions(), pem, '-P ' + h_l[2], h_l[0] + ':' + h_l[1] + '/' + file, offHelpers.objectPath() + '/' + file]);
         }
         if (offHelpers.transform() === 'enable' && offHelpers.transformFrom() !== '') {
           transport['transformFrom'](file);
           if (offHelpers.checkIntegrity(offHelpers.objectPath() + '/../tmp/' + file)) {
             readStream = fs.createReadStream(offHelpers.objectPath() + '/../tmp/' + file);
             readStream.pipe(process.stdout);
           }
         } else {
           if (offHelpers.checkIntegrity(offHelpers.objectPath() + '/' + file)) {
             readStream = fs.createReadStream(offHelpers.objectPath() + '/' + file);
             readStream.pipe(process.stdout);
           }
         }
       };
     } else if (mode === 'http') {
       transport['send'] = function(file) {
         offLogRepo('Http mode is read-only: ' + file + ' is stored in cache only');
       };
       transport['receive'] = function(file) {
         var f_l, readStream;
         f_l = file.split('/');
         if (fs.existsSync(offHelpers.objectPath() + '/' + f_l[0] + '/' + f_l[1]) === false) {
           mkdirParents(offHelpers.objectPath() + '/' + f_l[0] + '/' + f_l[1]);
         }
         exec('curl', [offHelpers.offCurlOptions(), offHelpers.objectPath() + '/' + file, offHelpers.offHttp() + '/' + file]);
         if (offHelpers.transform() === 'enable' && offHelpers.transformFrom() !== '') {
           transport['transformFrom'](file);
           if (offHelpers.checkIntegrity(offHelpers.objectPath() + '/../tmp/' + file)) {
             readStream = fs.createReadStream(offHelpers.objectPath() + '/../tmp/' + file);
             readStream.pipe(process.stdout);
           }
         } else {
           if (offHelpers.checkIntegrity(offHelpers.objectPath() + '/' + file)) {
             readStream = fs.createReadStream(offHelpers.objectPath() + '/' + file);
             readStream.pipe(process.stdout);
           }
         }
       };
     } else if (mode === 's3') {
       transport['send'] = function(file) {
         var AWS, fileStream, s3, upParams;
         AWS = require('aws-sdk');
         s3 = new AWS.S3({
           region: offHelpers.s3Region(),
           signatureVersion: 'v4'
         });
         upParams = {
           Bucket: offHelpers.s3Bucket(),
           Key: file,
           Body: ''
         };
         fileStream = fs.createReadStream(offHelpers.objectPath() + '/' + file);
         upParams.Body = fileStream;
         s3.upload(upParams, function(err, data) {});
       };
       transport['receive'] = function(file) {
         var AWS, dlParams, f_l, fileStream, s3;
         AWS = require('aws-sdk');
         s3 = new AWS.S3({
           region: offHelpers.s3Region(),
           signatureVersion: 'v4'
         });
         f_l = file.split('/');
         if (fs.existsSync(offHelpers.objectPath() + '/' + f_l[0] + '/' + f_l[1]) === false) {
           mkdirParents(offHelpers.objectPath() + '/' + f_l[0] + '/' + f_l[1]);
         }
         dlParams = {
           Bucket: offHelpers.s3Bucket(),
           Key: file
         };
         fileStream = fs.createWriteStream(offHelpers.objectPath() + '/' + file);
         fileStream.on('finish', function() {
           var readStream;
           if (offHelpers.transform() === 'enable' && offHelpers.transformFrom() !== '') {
             transport['transformFrom'](file);
             if (offHelpers.checkIntegrity(offHelpers.objectPath() + '/../tmp/' + file)) {
               readStream = fs.createReadStream(offHelpers.objectPath() + '/../tmp/' + file);
               readStream.pipe(process.stdout);
             }
           } else {
             if (offHelpers.checkIntegrity(offHelpers.objectPath() + '/' + file)) {
               readStream = fs.createReadStream(offHelpers.objectPath() + '/' + file);
               readStream.pipe(process.stdout);
             }
           }
         });
         s3.getObject(dlParams, function(err, data) {}).on('httpData', function(chunk) {
           fileStream.write(chunk);
         }).on('httpDone', function() {
           fileStream.end();
         });
       };
     }
   },
   'getOffFilePath': function(offFile) {
     return [offFile.slice(0, 2) + '/' + offFile.slice(2, 4) + '/' + offFile, offFile.slice(0, 2) + '/' + offFile.slice(2, 4)];
   }
 };
 
 
 /*
  * core
  */
 
 transport = {
   'send': function(src) {},
   'receive': function(src) {},
   'transformFrom': function(file) {
     var cmd, offFile, offFilePath, r;
     offFile = path.basename(file);
     offFilePath = offHelpers.getOffFilePath(offFile);
     if (fs.existsSync(offHelpers.objectPath() + '/../tmp/' + offFilePath[1]) === false) {
       mkdirParents(offHelpers.objectPath() + '/../tmp/' + offFilePath[1]);
     }
     cmd = offHelpers.transformFrom();
     cmd = cmd.replace('_1', offHelpers.objectPath() + '/' + file).replace('_2', offHelpers.objectPath() + '/../tmp/' + file);
     r = syncexec(cmd);
   }
 };
 
 offCommands = {
   'localSetup': function() {
     var hook;
     mkdirParents(offHelpers.objectPath());
     hook = offHelpers.gitRepoRoot() + '/.git/hooks/pre-push';
     if (fs.existsSync(hook) === false) {
       fs.writeFileSync(hook, offDEFAULTS.prePush);
       fs.chmodSync(hook, '755');
     }
   },
   'install': function(setCfg) {
     if (setCfg == null) {
       setCfg = gitConfig.set;
     }
     offCommands.localSetup();
     if (gitConfig.get('filter.off.clean') === '' || setCfg !== gitConfig.set) {
       if (setCfg === gitConfig.setThisRepo) {
         gitConfig.setLocal('filter.off.clean', 'git off clean %f');
       } else {
         setCfg('filter.off.clean', 'git off clean %f');
       }
     }
     if (gitConfig.get('filter.off.smudge') === '' || setCfg !== gitConfig.set) {
       if (setCfg === gitConfig.setThisRepo) {
         gitConfig.setLocal('filter.off.smudge', 'git off smudge %f');
       } else {
         setCfg('filter.off.smudge', 'git off smudge %f');
       }
     }
     if (offHelpers.log() === '' || setCfg !== gitConfig.set) {
       gitConfig.set('off.log', offDEFAULTS.log);
     }
     if (offHelpers.offMode() === '' || setCfg !== gitConfig.set) {
       setCfg('off.mode', offDEFAULTS.mode);
     }
     if (offHelpers.offIntegrity() === '' || setCfg !== gitConfig.set) {
       setCfg('off.integrity', offDEFAULTS.integrity);
     }
     if (offHelpers.offPem() === '' || setCfg !== gitConfig.set) {
       setCfg('off.pem', offDEFAULTS.pem);
     }
     if (offHelpers.offScp() === '' || setCfg !== gitConfig.set) {
       setCfg('off.scphost', offDEFAULTS.scpHost);
     }
     if (offHelpers.offScpUser() === '' || setCfg !== gitConfig.set) {
       setCfg('off.scpuser', offDEFAULTS.scpUser);
     }
     if (offHelpers.offSshOptions() === '' || setCfg !== gitConfig.set) {
       setCfg('off.sshoptions', offDEFAULTS.sshOptions);
     }
     if (offHelpers.offScpOptions() === '' || setCfg !== gitConfig.set) {
       setCfg('off.scpoptions', offDEFAULTS.scpOptions);
     }
     if (offHelpers.offRsyncOptions() === '' || setCfg !== gitConfig.set) {
       setCfg('off.rsyncoptions', offDEFAULTS.rsyncOptions);
     }
     if (offHelpers.offStore() === '' || setCfg !== gitConfig.set) {
       setCfg('off.store', offDEFAULTS.store);
     }
     if (offHelpers.offHttp() === '' || setCfg !== gitConfig.set) {
       setCfg('off.http', offDEFAULTS.http);
     }
     if (offHelpers.offCurlOptions() === '' || setCfg !== gitConfig.set) {
       setCfg('off.curloptions', offDEFAULTS.curlOptions);
     }
     if (offHelpers.offConfigAlways() === '' || setCfg !== gitConfig.set) {
       setCfg('off.configAlways', offDEFAULTS.configAlways);
     }
     if (offHelpers.s3Region() === '' || setCfg !== gitConfig.set) {
       setCfg('off.s3Region', offDEFAULTS.s3Region);
     }
     if (offHelpers.s3Bucket() === '' || setCfg !== gitConfig.set) {
       setCfg('off.s3Bucket', offDEFAULTS.s3Bucket);
     }
     if (offHelpers.transform() === '' || setCfg !== gitConfig.set) {
       setCfg('off.transform', offDEFAULTS.transform);
     }
     if (offHelpers.transformTo() === '' || setCfg !== gitConfig.set) {
       setCfg('off.transformTo', offDEFAULTS.transformTo);
     }
     if (offHelpers.transformFrom() === '' || setCfg !== gitConfig.set) {
       setCfg('off.transformFrom', offDEFAULTS.transformFrom);
     }
     if (runtimeConfig.offMode === 'copy') {
       mkdirParents(runtimeConfig.offStore);
     }
     if (runtimeConfig.offMode === 'scp' || runtimeConfig.offMode === 'rsync') {
       offHelpers.mkdirStore('');
     }
   },
   'mode': function(setCfg) {
     var len, mode;
     len = process.argv.length;
     mode = process.argv[len - 1];
     if (mode !== 'mode' && mode !== 'thisrepo') {
       setCfg('off.mode', mode);
     } else {
       console.log('off.mode '.blue.bold + offHelpers.offMode());
     }
   },
   'store': function(setCfg) {
     var len, store;
     len = process.argv.length;
     store = process.argv[len - 1];
     if (store !== 'store' && store !== 'thisrepo') {
       setCfg('off.store', store);
     } else {
       console.log('off.store '.blue.bold + offHelpers.offStore());
     }
   },
   'scp': function(setCfg) {
     var len, scpHost;
     len = process.argv.length;
     scpHost = process.argv[len - 1];
     if (scpHost !== 'scp' && scpHost !== 'thisrepo') {
       setCfg('off.scphost', scpHost);
     } else {
       console.log('off.scp '.blue.bold + offHelpers.offScp());
     }
   },
   'http': function(setCfg) {
     var http, len;
     len = process.argv.length;
     http = process.argv[len - 1];
     if (http !== 'http' && http !== 'thisrepo') {
       setCfg('off.http', http);
     } else {
       console.log('off.http '.blue.bold + offHelpers.offHttp());
     }
   },
   'curl': function(setCfg) {
     var curl, len;
     len = process.argv.length;
     curl = process.argv[len - 1];
     if (curl !== 'curl' && curl !== 'thisrepo') {
       setCfg('off.curloptions', curl);
     } else {
       console.log('off.curloptions '.blue.bold + offHelpers.offCurlOptions());
     }
   },
   'integrity': function(setCfg) {
     var integrity, len;
     len = process.argv.length;
     integrity = process.argv[len - 1];
     if (integrity !== 'integrity' && integrity !== 'thisrepo') {
       setCfg('off.integrity', integrity);
     } else {
       console.log('off.integrity '.blue.bold + offHelpers.offIntegrity());
     }
   },
   'pem': function(setCfg) {
     var len, pem;
     len = process.argv.length;
     pem = process.argv[len - 1];
     if (pem !== 'pem' && pem !== 'thisrepo') {
       setCfg('off.pem', pem);
     } else {
       console.log('off.pem '.blue.bold + offHelpers.offPem());
     }
   },
   'sshoptions': function(setCfg) {
     var len, sshoptions;
     len = process.argv.length;
     sshoptions = process.argv[len - 1];
     if (sshoptions !== 'sshoptions' && sshoptions !== 'thisrepo') {
       setCfg('off.sshoptions', sshoptions);
     } else {
       console.log('off.sshoptions '.blue.bold + offHelpers.offSshOptions());
     }
   },
   'scpoptions': function(setCfg) {
     var len, scpoptions;
     len = process.argv.length;
     scpoptions = process.argv[len - 1];
     if (scpoptions !== 'scpoptions' && scpoptions !== 'thisrepo') {
       setCfg('off.scpoptions', scpoptions);
     } else {
       console.log('off.scpoptions '.blue.bold + offHelpers.offScpOptions());
     }
   },
   'rsyncoptions': function(setCfg) {
     var len, rsyncoptions;
     len = process.argv.length;
     rsyncoptions = process.argv[len - 1];
     if (rsyncoptions !== 'rsyncoptions' && rsyncoptions !== 'thisrepo') {
       setCfg('off.rsyncoptions', rsyncoptions);
     } else {
       console.log('off.rsyncoptions '.blue.bold + offHelpers.offRsyncOptions());
     }
   },
   'scpUser': function(setCfg) {
     var len, scpUser;
     len = process.argv.length;
     scpUser = process.argv[len - 1];
     if (scpUser !== 'scpuser' && scpUser !== 'thisrepo') {
       setCfg('off.scpuser', scpUser);
     } else {
       console.log('off.scpuser '.blue.bold + offHelpers.offScpUser());
     }
   },
   'track': function() {
     var i, l, len1, r, ref;
     if (process.argv[3] !== void 0) {
       offCommands.install();
       fs.appendFileSync(offHelpers.gitRepoRoot() + '/.gitattributes', process.argv[3] + ' filter=off -text\n');
     } else {
       r = exec('listAttr', ['`cd ' + offHelpers.gitRepoRoot() + '; git ls-files`']);
       ref = r.stdout.split('\n');
       for (i = 0, len1 = ref.length; i < len1; i++) {
         l = ref[i];
         if (l.indexOf(': filter: off') !== -1) {
           console.log(l);
         }
       }
     }
   },
   'configAlways': function() {
     var configAlways, len;
     len = process.argv.length;
     configAlways = process.argv[len - 1];
     if (configAlways !== 'configAlways') {
       gitConfig.set('off.configAlways', configAlways);
     } else {
       console.log('off.configAlways '.blue.bold + offHelpers.offConfigAlways());
     }
   },
   's3region': function(setCfg) {
     var len, region;
     len = process.argv.length;
     region = process.argv[len - 1];
     if (region !== 's3region' && region !== 'thisrepo') {
       setCfg('off.s3region', region);
     } else {
       console.log('off.s3region '.blue.bold + offHelpers.s3Region());
     }
   },
   's3bucket': function(setCfg) {
     var bucket, len;
     len = process.argv.length;
     bucket = process.argv[len - 1];
     if (bucket !== 's3bucket' && bucket !== 'thisrepo') {
       setCfg('off.s3bucket', bucket);
     } else {
       console.log('off.s3bucket '.blue.bold + offHelpers.s3Bucket());
     }
   },
   'transform': function(setCfg) {
     var len, setting;
     len = process.argv.length;
     setting = process.argv[len - 1];
     if (setting !== 'transform' && setting !== 'thisrepo') {
       setCfg('off.transform', setting);
     } else {
       console.log('off.transform '.blue.bold + offHelpers.transform());
     }
   },
   'transformTo': function(setCfg) {
     var len, setting;
     len = process.argv.length;
     setting = process.argv[len - 1];
     if (setting !== 'transformTo' && setting !== 'thisrepo') {
       setCfg('off.transformTo', setting);
     } else {
       console.log('off.transformTo '.blue.bold + offHelpers.transformTo());
     }
   },
   'transformFrom': function(setCfg) {
     var len, setting;
     len = process.argv.length;
     setting = process.argv[len - 1];
     if (setting !== 'transformFrom' && setting !== 'thisrepo') {
       setCfg('off.transformFrom', setting);
     } else {
       console.log('off.transformFrom '.blue.bold + offHelpers.transformFrom());
     }
   },
   'clean': function() {
     var file, offFile, offFilePath, pipe, quotedFile, r, size, writeStream;
     offCommands.localSetup();
     file = process.argv[3];
     size = fs.statSync(file).size;
     quotedFile = '"' + file + '"';
     r = exec('sha', [quotedFile]);
     offFile = r.stdout.split(' ')[0].trim();
     offFilePath = offHelpers.getOffFilePath(offFile);
     if (fs.existsSync(offHelpers.objectPath() + '/' + offFilePath[1]) === false) {
       mkdirParents(offHelpers.objectPath() + '/' + offFilePath[1]);
     }
     offFilePath = offFilePath[0];
     if (fs.existsSync(offHelpers.objectPath() + '/' + offFilePath) === false) {
       writeStream = fs.createWriteStream(offHelpers.objectPath() + '/' + offFilePath);
       pipe = process.stdin.pipe(writeStream);
       pipe.on('finish', function() {
         var cmd;
         fs.chmodSync(offHelpers.objectPath() + '/' + offFilePath, '444');
         if (offHelpers.transform() === 'enable' && offHelpers.transformTo() !== '') {
           if (fs.existsSync(offHelpers.objectPath() + '/../tmp' === false)) {
             mkdirParents(offHelpers.objectPath() + '/../tmp');
           }
           offFilePath = offHelpers.getOffFilePath(offFile);
           if (fs.existsSync(offHelpers.objectPath() + '/../tmp/' + offFilePath[1]) === false) {
             mkdirParents(offHelpers.objectPath() + '/../tmp/' + offFilePath[1]);
           }
           offFilePath = offFilePath[0];
           exec('mv', [offHelpers.objectPath() + '/' + offFilePath, offHelpers.objectPath() + '/../tmp/' + offFilePath]);
           cmd = offHelpers.transformTo();
           cmd = cmd.replace('_1', offHelpers.objectPath() + '/../tmp/' + offFilePath).replace('_2', offHelpers.objectPath() + '/' + offFilePath);
           r = syncexec(cmd);
         }
       });
     } else {
       writeStream = fs.createWriteStream('/dev/null');
       process.stdin.pipe(writeStream);
     }
     console.log(offDEFAULTS.offSignature + offFile + ' size:' + size);
   },
   'prepush': function() {
     var rl;
     offHelpers.setTransport();
     rl = readline.createInterface({
       input: process.stdin,
       output: process.stdout,
       terminal: false
     });
     rl.on('line', function(line) {
       offCommands.push(line);
     });
   },
   'push': function(line) {
     var commitListToPush, i, j, len, len1, len2, line_l, localRef, localSha, objInfo, objInfoList, offFile, offFilePath, offRef, oi, r, remoteName, remoteRef, remoteSha, sha, url;
     len = process.argv.length;
     remoteName = process.argv[len - 2];
     url = process.argv[len - 1];
     line_l = line.split(' ');
     localRef = line_l[0];
     localSha = line_l[1];
     remoteRef = line_l[2];
     remoteSha = line_l[3];
     r = 0;
     if (remoteSha === '0000000000000000000000000000000000000000') {
       r = exec('gitListEmptyRemote', [localSha]);
     } else {
       r = exec('gitList', [localSha, '^' + remoteSha]);
     }
     commitListToPush = r.stdout.split('\n');
     commitListToPush = commitListToPush.slice(0, commitListToPush.length - 1);
     for (i = 0, len1 = commitListToPush.length; i < len1; i++) {
       sha = commitListToPush[i];
       r = exec('gitDiff', [sha]);
       objInfoList = r.stdout.split('\n');
       objInfoList = objInfoList.slice(1, objInfoList.length - 1);
       for (j = 0, len2 = objInfoList.length; j < len2; j++) {
         oi = objInfoList[j];
         objInfo = oi.split(' ');
         if (objInfo[oiNAME].slice(0, 1) !== 'D') {
           r = exec('gitCat', [objInfo[oiOID]]);
           offRef = r.stdout.split('\n')[0];
           if (offRef.indexOf(offDEFAULTS.offSignature) !== -1) {
             offFile = offRef.split(':')[1].split(' ')[0];
             offFilePath = offHelpers.getOffFilePath(offFile)[0];
             transport.send(offFilePath);
           }
         }
       }
     }
   },
   'smudge': function() {
     var status;
     offHelpers.setTransport();
     offCommands.localSetup();
     status = 'header';
     process.stdin.on('readable', function() {
       var cmd, data, decoder, header, offFile, offFilePath, r, readStream;
       if (status === 'header') {
         status = 'stream';
         data = process.stdin.read(offDEFAULTS.offSignature.length + offDEFAULTS.shaLength);
         decoder = new StringDecoder('utf8');
         if (data === null) {
           offLogRepo('smudge error: cant get data from stdin.');
           process.exit(1);
         }
         header = decoder.write(data);
         if (header.slice(0, offDEFAULTS.offSignature.length) === offDEFAULTS.offSignature) {
           offFile = header.split(':')[1];
           offFilePath = offHelpers.getOffFilePath(offFile)[0];
           if (fs.existsSync(offHelpers.objectPath() + '/' + offFilePath) === true) {
             if (offHelpers.transform() === 'enable' && offHelpers.transformFrom() !== '') {
               if (fs.existsSync(offHelpers.objectPath() + '/../tmp' === false)) {
                 mkdirParents(offHelpers.objectPath() + '/../tmp');
               }
               offFilePath = offHelpers.getOffFilePath(offFile);
               if (fs.existsSync(offHelpers.objectPath() + '/../tmp/' + offFilePath[1]) === false) {
                 mkdirParents(offHelpers.objectPath() + '/../tmp/' + offFilePath[1]);
               }
               offFilePath = offFilePath[0];
               cmd = offHelpers.transformFrom();
               cmd = cmd.replace('_1', offHelpers.objectPath() + '/' + offFilePath).replace('_2', offHelpers.objectPath() + '/../tmp/' + offFilePath);
               r = syncexec(cmd);
               readStream = fs.createReadStream(offHelpers.objectPath() + '/../tmp/' + offFilePath);
             } else {
               readStream = fs.createReadStream(offHelpers.objectPath() + '/' + offFilePath);
             }
             readStream.pipe(process.stdout);
           } else {
             transport.receive(offFilePath);
           }
         } else {
           process.stdout.write(data);
           process.stdin.pipe(process.stdout);
         }
       }
     });
   },
   'copyTo': function() {
     if (process.argv[3] === void 0) {
       console.log('Choose a mode where to copy the cache'.red.bold);
       return;
     }
     offHelpers.setTransport(process.argv[3]);
     offHelpers.copyTo();
   },
   'pushTo': function() {
     if (offHelpers.offMode() !== void 0) {
       offHelpers.setTransport(offHelpers.offMode());
       offHelpers.copyTo();
     }
   },
   'clearAll': function() {
     offCommands.clearStore();
     offCommands.clearCache();
     rmAll(offHelpers.getLog());
   },
   'clearCache': function() {
     rmAll(offHelpers.gitRepoRoot() + '/.git/off');
   },
   'clearStore': function() {
     if (offHelpers.offMode() === 'copy') {
       rmAll(offHelpers.offStore());
     }
     if (offHelpers.offMode() === 'scp' || offHelpers.offMode() === 'rsync') {
       offHelpers.rmAllStore('');
     }
   },
   'clearTmp': function() {
     rmAll(offHelpers.gitRepoRoot() + '/.git/off/tmp');
   },
   'defaults': function() {
     var i, k, len1, ref;
     ref = Object.keys(offDEFAULTS);
     for (i = 0, len1 = ref.length; i < len1; i++) {
       k = ref[i];
       console.log(k.blue.bold + ' ' + offDEFAULTS[k]);
     }
   },
   'env': function() {
     console.log('off.mode '.blue.bold + offHelpers.offMode());
     console.log('off.integrity '.blue.bold + offHelpers.offIntegrity());
     console.log('off.pem '.blue.bold + offHelpers.offPem());
     console.log('off.sshoptions '.blue.bold + offHelpers.offSshOptions());
     console.log('off.scpoptions '.blue.bold + offHelpers.offScpOptions());
     console.log('off.rsyncoptions '.blue.bold + offHelpers.offRsyncOptions());
     console.log('off.store '.blue.bold + offHelpers.offStore());
     console.log('off.http '.blue.bold + offHelpers.offHttp());
     console.log('off.curloptions '.blue.bold + offHelpers.offCurlOptions());
     console.log('off.scphost '.blue.bold + offHelpers.offScp());
     console.log('off.scpuser '.blue.bold + offHelpers.offScpUser());
     console.log('off.log '.blue.bold + offHelpers.getLog());
     console.log('off.configAlways '.blue.bold + offHelpers.offConfigAlways());
     console.log('off.s3region '.blue.bold + offHelpers.s3Region());
     console.log('off.s3bucket '.blue.bold + offHelpers.s3Bucket());
     console.log('off.transform '.blue.bold + offHelpers.transform());
     console.log('off.transformTo '.blue.bold + offHelpers.transformTo());
     console.log('off.transformFrom '.blue.bold + offHelpers.transformFrom());
   },
   'help': function() {
     var c, i, len1, ref;
     console.log('git-off help\n'.green.bold);
     if (process.argv[3] === void 0) {
       console.log('# Quick Start'.green.bold);
       console.log('Setup:');
       console.log("git off track '*.bin'");
       console.log('git add .');
       console.log('git commit');
       console.log('git push');
       console.log('git checkout master');
       console.log('\n# Other'.green.bold);
       console.log('git off install');
       console.log('git off mode scp');
       console.log('git off scp localhost:/tmp/offStore');
       console.log('git off scpuser username');
       console.log('git off cc');
       console.log('git off ca');
       console.log('git off env');
       console.log('git off defaults\n');
       ref = Object.keys(COMMAND_MAP);
       for (i = 0, len1 = ref.length; i < len1; i++) {
         c = ref[i];
         showCommandHelp(c);
       }
       console.log('\nGo to https://noulin.net/git-off/file/README.md.html for more information'.green.bold);
     } else {
       if (COMMAND_MAP[process.argv[3]] === void 0) {
         console.log(COMMAND_MAP.help.h.green);
       } else {
         showCommandHelp(process.argv[3]);
       }
     }
   }
 };
 
 
 /*
  * main
  */
 
 thisrepo = function(cmd) {
   if (process.argv[3] !== 'thisrepo') {
     cmd(gitConfig['set']);
   } else {
     cmd(gitConfig['setThisRepo']);
   }
 };
 
 showCommandHelp = function(cmd) {
   var l_l;
   l_l = COMMAND_MAP[cmd].h.split('\n');
   console.log(l_l[0]);
   l_l = l_l.slice(1);
   console.log(l_l.join('\n').green);
 };
 
 COMMAND_MAP = {
   'install': {
     f: function() {
       thisrepo(offCommands['install']);
     },
     h: 'git off install [thisrepo]\n  setup git config (default global)\n  thisrepo sets up config in current repo'
   },
   'mode': {
     f: function() {
       thisrepo(offCommands['mode']);
     },
     h: 'git off mode [thisrepo] [copy|rsync|scp|http|s3]\n  set/show git off mode'
   },
   'store': {
     f: function() {
       thisrepo(offCommands['store']);
     },
     h: 'git off store [thisrepo] [path]\n  set/show git off store path for copy mode'
   },
   'scp': {
     f: function() {
       thisrepo(offCommands['scp']);
     },
     h: 'git off scp [thisrepo] [host]\n  setup scp config\n  host has format host:path, user@host:path, user@host:port/path\n  Example: localhost:/tmp/offStore'
   },
   'http': {
     f: function() {
       thisrepo(offCommands['http']);
     },
     h: 'git off http [thisrepo] [host]\n  setup http config\n  host has format http://host/path\n  Example: http://localhost/offStore'
   },
   'curl': {
     f: function() {
       thisrepo(offCommands['curl']);
     },
     h: 'git off curl [thisrepo] [options]\n  setup curl config'
   },
   'integrity': {
     f: function() {
       thisrepo(offCommands['integrity']);
     },
     h: 'git off integrity [thisrepo] [enable|disable]\n  set/show git off integrity.\n  when enabled, the SHA of the file received from the store is\n  checked again the SHA of the original file'
   },
   'pem': {
     f: function() {
       thisrepo(offCommands['pem']);
     },
     h: "git off pem [thisrepo] [pathToPrivateKey]\n  set/show git off pem.\n  off.pem is the private key for ssh, rsync and scp\n  set 'offNoValue' to set an empty value (useful when there are multiple configs)"
   },
   'sshoptions': {
     f: function() {
       thisrepo(offCommands['sshoptions']);
     },
     h: 'git off sshoptions [thisrepo] [options]\n  set/show git off sshoptions'
   },
   'scpoptions': {
     f: function() {
       thisrepo(offCommands['scpoptions']);
     },
     h: 'git off scpoptions [thisrepo] [options]\n  set/show git off scpoptions'
   },
   'rsyncoptions': {
     f: function() {
       thisrepo(offCommands['rsyncoptions']);
     },
     h: 'git off rsyncoptions [thisrepo] [options]\n  set/show git off rsyncoptions'
   },
   'scpuser': {
     f: function() {
       thisrepo(offCommands['scpUser']);
     },
     h: 'git off scpuser [thisrepo] [username]\n  setup scp username config'
   },
   'track': {
     f: function() {
       offCommands.track();
     },
     h: "git off track\n  setup gitattribute filters\n  example: git off track '*.bin'\n  without parameter, list git off attributes\n  calls git off install"
   },
   'configAlways': {
     f: function() {
       offCommands.configAlways();
     },
     h: "git off configAlways [''|GIT_OFF_CONFIG|repo|global]\n  '' disable configAlways\n  GIT_OFF_CONFIG load all configurations from $GIT_OFF_CONFIG\n  repo load all configurations from current git repo\n  global load all configurations from global git config\n  set 'offNoValue' to set an empty value"
   },
   's3region': {
     f: function() {
       thisrepo(offCommands['s3region']);
     },
     h: 'git off s3region [thisrepo] [region]\n  setup amazon s3 region for the bucket'
   },
   's3bucket': {
     f: function() {
       thisrepo(offCommands['s3bucket']);
     },
     h: 'git off s3bucket [thisrepo] [bucket]\n  setup amazon s3 bucket'
   },
   'transform': {
     f: function() {
       thisrepo(offCommands['transform']);
     },
     h: 'git off transform [thisrepo] [enable|disable]\n  enable transform in clean and smudge filters'
   },
   'transformTo': {
     f: function() {
       thisrepo(offCommands['transformTo']);
     },
     h: "git off transformTo [thisrepo] ['cmd _1 _2']\n  setup transform command for clear filter\n  When the command is empty the regular transport is performed"
   },
   'transformFrom': {
     f: function() {
       thisrepo(offCommands['transformFrom']);
     },
     h: "git off transformFrom [thisrepo] ['cmd _1 _2']\n  setup transform command for smudge filter\n  When the command is empty the regular transport is performed"
   },
   'clean': {
     f: function() {
       offCommands.clean();
     },
     h: 'git off clean\n  internal filter\n  dont use directly'
   },
   'pre-push': {
     f: function() {
       offCommands.prepush();
     },
     h: 'git off pre-push\n  internal filter\n  dont use directly'
   },
   'smudge': {
     f: function() {
       offCommands.smudge();
     },
     h: 'git off smudge\n  internal filter\n  dont use directly'
   },
   'copyTo': {
     f: function() {
       offCommands.copyTo();
     },
     h: 'git off copyTo [copy|rsync|scp|s3]\n  copy cache to store for specified mode'
   },
   'push': {
     f: function() {
       offCommands.pushTo();
     },
     h: 'git off push\n  copy cache to store for selected mode'
   },
   'clearAll': {
     f: function() {
       offCommands.clearAll();
     },
     h: 'git off clearAll\n  delete store, cache and log'
   },
   'ca': {
     f: function() {
       offCommands.clearAll();
     },
     h: 'git off ca\n  delete store, cache and log'
   },
   'clearCache': {
     f: function() {
       offCommands.clearCache();
     },
     h: 'git off clearCache\n  delete cache in current git'
   },
   'cc': {
     f: function() {
       offCommands.clearCache();
     },
     h: 'git off cc\n  delete cache in current git'
   },
   'clearStore': {
     f: function() {
       offCommands.clearStore();
     },
     h: 'git off clearStore\n  delete store'
   },
   'cs': {
     f: function() {
       offCommands.clearStore();
     },
     h: 'git off ct\n  delete store'
   },
   'clearTmp': {
     f: function() {
       offCommands.clearTmp();
     },
     h: 'git off clearTmp\n  delete tmp in git off cache\n  Useful when transform is enabled'
   },
   'ct': {
     f: function() {
       offCommands.clearTmp();
     },
     h: 'git off cs\n  delete tmp in git off cache\n  Useful when transform is enabled'
   },
   'defaults': {
     f: function() {
       offCommands.defaults();
     },
     h: 'git off defaults\n  shows first time config'
   },
   'env': {
     f: function() {
       offCommands.env();
     },
     h: 'git off env\n  shows config'
   },
   'help': {
     f: function() {
       offCommands.help();
     },
     h: 'git off help [cmd]\n  git off help. Run git off help command to get help for a specific command.'
   }
 };
 
 if (process.argv[2] === void 0) {
   COMMAND_MAP.help.f();
 } else {
   if (COMMAND_MAP[process.argv[2]] === void 0) {
     COMMAND_MAP['help'].f();
   } else {
     COMMAND_MAP[process.argv[2]].f();
   }
 }
 
 
 /*
  * exports for unit tests
  * export everything
  */
 
 module.exports = {
   runtimeConfig: runtimeConfig,
   offDEFAULTS: offDEFAULTS,
   expandHome: expandHome,
   gitConfig: gitConfig,
   offLog: offLog,
   offLogRepo: offLogRepo,
   exec: exec,
   mkdirParents: mkdirParents,
   rmAll: rmAll,
   copy: copy,
   walkSync: walkSync,
   offHelpers: offHelpers,
   transport: transport,
   offCommands: offCommands,
   thisrepo: thisrepo,
   showCommandHelp: showCommandHelp,
   COMMAND_MAP: COMMAND_MAP
 };