jfrog-cli-v2-jf 2.6.0

package/node-v8.11.1-linux-x64/lib/node_modules/npm/lib/config/load-prefix.js

@@ -0,0 +1,51 @@
+module.exports = loadPrefix
+
+var findPrefix = require('find-npm-prefix')
+var path = require('path')
+
+function loadPrefix (cb) {
+  var cli = this.list[0]
+
+  Object.defineProperty(this, 'prefix',
+    {
+      set: function (prefix) {
+        var g = this.get('global')
+        this[g ? 'globalPrefix' : 'localPrefix'] = prefix
+      }.bind(this),
+      get: function () {
+        var g = this.get('global')
+        return g ? this.globalPrefix : this.localPrefix
+      }.bind(this),
+      enumerable: true
+    })
+
+  Object.defineProperty(this, 'globalPrefix',
+    {
+      set: function (prefix) {
+        this.set('prefix', prefix)
+      }.bind(this),
+      get: function () {
+        return path.resolve(this.get('prefix'))
+      }.bind(this),
+      enumerable: true
+    })
+
+  var p
+  Object.defineProperty(this, 'localPrefix',
+    { set: function (prefix) { p = prefix },
+      get: function () { return p },
+    enumerable: true })
+
+  // try to guess at a good node_modules location.
+  // If we are *explicitly* given a prefix on the cli, then
+  // always use that.  otherwise, infer local prefix from cwd.
+  if (Object.prototype.hasOwnProperty.call(cli, 'prefix')) {
+    p = path.resolve(cli.prefix)
+    process.nextTick(cb)
+  } else {
+    findPrefix(process.cwd()).then((found) => {
+      p = found
+      cb()
+    }, cb)
+  }
+}

package/node-v8.11.1-linux-x64/lib/node_modules/npm/lib/config/load-uid.js

@@ -0,0 +1,15 @@
+module.exports = loadUid
+
+var getUid = require('uid-number')
+
+// Call in the context of a npmconf object
+
+function loadUid (cb) {
+  // if we're not in unsafe-perm mode, then figure out who
+  // to run stuff as.  Do this first, to support `npm update npm -g`
+  if (!this.get('unsafe-perm')) {
+    getUid(this.get('user'), this.get('group'), cb)
+  } else {
+    process.nextTick(cb)
+  }
+}

package/node-v8.11.1-linux-x64/lib/node_modules/npm/lib/config/nerf-dart.js

@@ -0,0 +1,23 @@
+var url = require('url')
+
+module.exports = toNerfDart
+
+/**
+ * Maps a URL to an identifier.
+ *
+ * Name courtesy schiffertronix media LLC, a New Jersey corporation
+ *
+ * @param {String} uri The URL to be nerfed.
+ *
+ * @returns {String} A nerfed URL.
+ */
+function toNerfDart (uri) {
+  var parsed = url.parse(uri)
+  delete parsed.protocol
+  delete parsed.auth
+  delete parsed.query
+  delete parsed.search
+  delete parsed.hash
+
+  return url.resolve(url.format(parsed), '.')
+}

package/node-v8.11.1-linux-x64/lib/node_modules/npm/lib/config/pacote.js

@@ -0,0 +1,139 @@
+'use strict'
+
+const Buffer = require('safe-buffer').Buffer
+
+const crypto = require('crypto')
+const npm = require('../npm')
+const log = require('npmlog')
+let pack
+const path = require('path')
+
+let effectiveOwner
+
+const npmSession = crypto.randomBytes(8).toString('hex')
+log.verbose('npm-session', npmSession)
+
+module.exports = pacoteOpts
+function pacoteOpts (moreOpts) {
+  if (!pack) {
+    pack = require('../pack.js')
+  }
+  const ownerStats = calculateOwner()
+  const opts = {
+    cache: path.join(npm.config.get('cache'), '_cacache'),
+    ca: npm.config.get('ca'),
+    cert: npm.config.get('cert'),
+    defaultTag: npm.config.get('tag'),
+    dirPacker: pack.packGitDep,
+    hashAlgorithm: 'sha1',
+    key: npm.config.get('key'),
+    localAddress: npm.config.get('local-address'),
+    log: log,
+    maxAge: npm.config.get('cache-min'),
+    maxSockets: npm.config.get('maxsockets'),
+    npmSession: npmSession,
+    offline: npm.config.get('offline'),
+    preferOffline: npm.config.get('prefer-offline') || npm.config.get('cache-min') > 9999,
+    preferOnline: npm.config.get('prefer-online') || npm.config.get('cache-max') <= 0,
+    projectScope: npm.projectScope,
+    proxy: npm.config.get('https-proxy') || npm.config.get('proxy'),
+    refer: npm.registry.refer,
+    registry: npm.config.get('registry'),
+    retry: {
+      retries: npm.config.get('fetch-retries'),
+      factor: npm.config.get('fetch-retry-factor'),
+      minTimeout: npm.config.get('fetch-retry-mintimeout'),
+      maxTimeout: npm.config.get('fetch-retry-maxtimeout')
+    },
+    scope: npm.config.get('scope'),
+    strictSSL: npm.config.get('strict-ssl'),
+    userAgent: npm.config.get('user-agent'),
+
+    dmode: npm.modes.exec,
+    fmode: npm.modes.file,
+    umask: npm.modes.umask
+  }
+
+  if (ownerStats.uid != null || ownerStats.gid != null) {
+    Object.assign(opts, ownerStats)
+  }
+
+  npm.config.keys.forEach(function (k) {
+    const authMatchGlobal = k.match(
+      /^(_authToken|username|_password|password|email|always-auth|_auth)$/
+    )
+    const authMatchScoped = k[0] === '/' && k.match(
+      /(.*):(_authToken|username|_password|password|email|always-auth|_auth)$/
+    )
+
+    // if it matches scoped it will also match global
+    if (authMatchGlobal || authMatchScoped) {
+      let nerfDart = null
+      let key = null
+      let val = null
+
+      if (!opts.auth) { opts.auth = {} }
+
+      if (authMatchScoped) {
+        nerfDart = authMatchScoped[1]
+        key = authMatchScoped[2]
+        val = npm.config.get(k)
+        if (!opts.auth[nerfDart]) {
+          opts.auth[nerfDart] = {
+            alwaysAuth: !!npm.config.get('always-auth')
+          }
+        }
+      } else {
+        key = authMatchGlobal[1]
+        val = npm.config.get(k)
+        opts.auth.alwaysAuth = !!npm.config.get('always-auth')
+      }
+
+      const auth = authMatchScoped ? opts.auth[nerfDart] : opts.auth
+      if (key === '_authToken') {
+        auth.token = val
+      } else if (key.match(/password$/i)) {
+        auth.password =
+        // the config file stores password auth already-encoded. pacote expects
+        // the actual username/password pair.
+        Buffer.from(val, 'base64').toString('utf8')
+      } else if (key === 'always-auth') {
+        auth.alwaysAuth = val === 'false' ? false : !!val
+      } else {
+        auth[key] = val
+      }
+    }
+
+    if (k[0] === '@') {
+      if (!opts.scopeTargets) { opts.scopeTargets = {} }
+      opts.scopeTargets[k.replace(/:registry$/, '')] = npm.config.get(k)
+    }
+  })
+
+  Object.keys(moreOpts || {}).forEach((k) => {
+    opts[k] = moreOpts[k]
+  })
+
+  return opts
+}
+
+function calculateOwner () {
+  if (!effectiveOwner) {
+    effectiveOwner = { uid: 0, gid: 0 }
+
+    // Pretty much only on windows
+    if (!process.getuid) {
+      return effectiveOwner
+    }
+
+    effectiveOwner.uid = +process.getuid()
+    effectiveOwner.gid = +process.getgid()
+
+    if (effectiveOwner.uid === 0) {
+      if (process.env.SUDO_UID) effectiveOwner.uid = +process.env.SUDO_UID
+      if (process.env.SUDO_GID) effectiveOwner.gid = +process.env.SUDO_GID
+    }
+  }
+
+  return effectiveOwner
+}

package/node-v8.11.1-linux-x64/lib/node_modules/npm/lib/config/reg-client.js

@@ -0,0 +1,29 @@
+'use strict'
+
+module.exports = regClientConfig
+function regClientConfig (npm, log, config) {
+  return {
+    proxy: {
+      http: config.get('proxy'),
+      https: config.get('https-proxy'),
+      localAddress: config.get('local-address')
+    },
+    ssl: {
+      certificate: config.get('cert'),
+      key: config.get('key'),
+      ca: config.get('ca'),
+      strict: config.get('strict-ssl')
+    },
+    retry: {
+      retries: config.get('fetch-retries'),
+      factor: config.get('fetch-retry-factor'),
+      minTimeout: config.get('fetch-retry-mintimeout'),
+      maxTimeout: config.get('fetch-retry-maxtimeout')
+    },
+    userAgent: config.get('user-agent'),
+    log: log,
+    defaultTag: config.get('tag'),
+    maxSockets: config.get('maxsockets'),
+    scope: npm.projectScope
+  }
+}

package/node-v8.11.1-linux-x64/lib/node_modules/npm/lib/config/set-credentials-by-uri.js

@@ -0,0 +1,39 @@
+var assert = require('assert')
+
+var toNerfDart = require('./nerf-dart.js')
+
+module.exports = setCredentialsByURI
+
+function setCredentialsByURI (uri, c) {
+  assert(uri && typeof uri === 'string', 'registry URL is required')
+  assert(c && typeof c === 'object', 'credentials are required')
+
+  var nerfed = toNerfDart(uri)
+
+  if (c.token) {
+    this.set(nerfed + ':_authToken', c.token, 'user')
+    this.del(nerfed + ':_password', 'user')
+    this.del(nerfed + ':username', 'user')
+    this.del(nerfed + ':email', 'user')
+    this.del(nerfed + ':always-auth', 'user')
+  } else if (c.username || c.password || c.email) {
+    assert(c.username, 'must include username')
+    assert(c.password, 'must include password')
+    assert(c.email, 'must include email address')
+
+    this.del(nerfed + ':_authToken', 'user')
+
+    var encoded = new Buffer(c.password, 'utf8').toString('base64')
+    this.set(nerfed + ':_password', encoded, 'user')
+    this.set(nerfed + ':username', c.username, 'user')
+    this.set(nerfed + ':email', c.email, 'user')
+
+    if (c.alwaysAuth !== undefined) {
+      this.set(nerfed + ':always-auth', c.alwaysAuth, 'user')
+    } else {
+      this.del(nerfed + ':always-auth', 'user')
+    }
+  } else {
+    throw new Error('No credentials to set.')
+  }
+}

package/node-v8.11.1-linux-x64/lib/node_modules/npm/lib/config/set-user.js

@@ -0,0 +1,29 @@
+module.exports = setUser
+
+var assert = require('assert')
+var path = require('path')
+var fs = require('fs')
+var mkdirp = require('mkdirp')
+
+function setUser (cb) {
+  var defaultConf = this.root
+  assert(defaultConf !== Object.prototype)
+
+  // If global, leave it as-is.
+  // If not global, then set the user to the owner of the prefix folder.
+  // Just set the default, so it can be overridden.
+  if (this.get('global')) return cb()
+  if (process.env.SUDO_UID) {
+    defaultConf.user = +(process.env.SUDO_UID)
+    return cb()
+  }
+
+  var prefix = path.resolve(this.get('prefix'))
+  mkdirp(prefix, function (er) {
+    if (er) return cb(er)
+    fs.stat(prefix, function (er, st) {
+      defaultConf.user = st && st.uid
+      return cb(er)
+    })
+  })
+}

package/node-v8.11.1-linux-x64/lib/node_modules/npm/lib/config.js

@@ -0,0 +1,280 @@
+module.exports = config
+
+var log = require('npmlog')
+var npm = require('./npm.js')
+var npmconf = require('./config/core.js')
+var fs = require('graceful-fs')
+var writeFileAtomic = require('write-file-atomic')
+var types = npmconf.defs.types
+var ini = require('ini')
+var editor = require('editor')
+var os = require('os')
+var umask = require('./utils/umask')
+var usage = require('./utils/usage')
+var output = require('./utils/output')
+var noProgressTillDone = require('./utils/no-progress-while-running').tillDone
+
+config.usage = usage(
+  'config',
+  'npm config set <key> <value>' +
+  '\nnpm config get [<key>]' +
+  '\nnpm config delete <key>' +
+  '\nnpm config list [--json]' +
+  '\nnpm config edit' +
+  '\nnpm set <key> <value>' +
+  '\nnpm get [<key>]'
+)
+config.completion = function (opts, cb) {
+  var argv = opts.conf.argv.remain
+  if (argv[1] !== 'config') argv.unshift('config')
+  if (argv.length === 2) {
+    var cmds = ['get', 'set', 'delete', 'ls', 'rm', 'edit']
+    if (opts.partialWord !== 'l') cmds.push('list')
+    return cb(null, cmds)
+  }
+
+  var action = argv[2]
+  switch (action) {
+    case 'set':
+      // todo: complete with valid values, if possible.
+      if (argv.length > 3) return cb(null, [])
+      // fallthrough
+      /*eslint no-fallthrough:0*/
+    case 'get':
+    case 'delete':
+    case 'rm':
+      return cb(null, Object.keys(types))
+    case 'edit':
+    case 'list':
+    case 'ls':
+      return cb(null, [])
+    default:
+      return cb(null, [])
+  }
+}
+
+// npm config set key value
+// npm config get key
+// npm config list
+function config (args, cb) {
+  var action = args.shift()
+  switch (action) {
+    case 'set':
+      return set(args[0], args[1], cb)
+    case 'get':
+      return get(args[0], cb)
+    case 'delete':
+    case 'rm':
+    case 'del':
+      return del(args[0], cb)
+    case 'list':
+    case 'ls':
+      return npm.config.get('json') ? listJson(cb) : list(cb)
+    case 'edit':
+      return edit(cb)
+    default:
+      return unknown(action, cb)
+  }
+}
+
+function edit (cb) {
+  var e = npm.config.get('editor')
+  var which = npm.config.get('global') ? 'global' : 'user'
+  var f = npm.config.get(which + 'config')
+  if (!e) return cb(new Error('No EDITOR config or environ set.'))
+  npm.config.save(which, function (er) {
+    if (er) return cb(er)
+    fs.readFile(f, 'utf8', function (er, data) {
+      if (er) data = ''
+      data = [
+        ';;;;',
+        '; npm ' + (npm.config.get('global')
+                  ? 'globalconfig' : 'userconfig') + ' file',
+        '; this is a simple ini-formatted file',
+        '; lines that start with semi-colons are comments.',
+        '; read `npm help config` for help on the various options',
+        ';;;;',
+        '',
+        data
+      ].concat([
+        ';;;;',
+        '; all options with default values',
+        ';;;;'
+      ]).concat(Object.keys(npmconf.defaults).reduce(function (arr, key) {
+        var obj = {}
+        obj[key] = npmconf.defaults[key]
+        if (key === 'logstream') return arr
+        return arr.concat(
+          ini.stringify(obj)
+            .replace(/\n$/m, '')
+            .replace(/^/g, '; ')
+            .replace(/\n/g, '\n; ')
+            .split('\n'))
+      }, []))
+      .concat([''])
+      .join(os.EOL)
+      writeFileAtomic(
+        f,
+        data,
+        function (er) {
+          if (er) return cb(er)
+          editor(f, { editor: e }, noProgressTillDone(cb))
+        }
+      )
+    })
+  })
+}
+
+function del (key, cb) {
+  if (!key) return cb(new Error('no key provided'))
+  var where = npm.config.get('global') ? 'global' : 'user'
+  npm.config.del(key, where)
+  npm.config.save(where, cb)
+}
+
+function set (key, val, cb) {
+  if (key === undefined) {
+    return unknown('', cb)
+  }
+  if (val === undefined) {
+    if (key.indexOf('=') !== -1) {
+      var k = key.split('=')
+      key = k.shift()
+      val = k.join('=')
+    } else {
+      val = ''
+    }
+  }
+  key = key.trim()
+  val = val.trim()
+  log.info('config', 'set %j %j', key, val)
+  var where = npm.config.get('global') ? 'global' : 'user'
+  if (key.match(/umask/)) val = umask.fromString(val)
+  npm.config.set(key, val, where)
+  npm.config.save(where, cb)
+}
+
+function get (key, cb) {
+  if (!key) return list(cb)
+  if (!publicVar(key)) {
+    return cb(new Error('---sekretz---'))
+  }
+  var val = npm.config.get(key)
+  if (key.match(/umask/)) val = umask.toString(val)
+  output(val)
+  cb()
+}
+
+function sort (a, b) {
+  return a > b ? 1 : -1
+}
+
+function publicVar (k) {
+  return !(k.charAt(0) === '_' || k.indexOf(':_') !== -1)
+}
+
+function getKeys (data) {
+  return Object.keys(data).filter(publicVar).sort(sort)
+}
+
+function listJson (cb) {
+  const publicConf = npm.config.keys.reduce((publicConf, k) => {
+    var value = npm.config.get(k)
+
+    if (publicVar(k) &&
+        // argv is not really config, it's command config
+        k !== 'argv' &&
+        // logstream is a Stream, and would otherwise produce circular refs
+        k !== 'logstream') publicConf[k] = value
+
+    return publicConf
+  }, {})
+
+  output(JSON.stringify(publicConf, null, 2))
+  return cb()
+}
+
+function listFromSource (title, conf, long) {
+  var confKeys = getKeys(conf)
+  var msg = ''
+
+  if (confKeys.length) {
+    msg += '; ' + title + '\n'
+    confKeys.forEach(function (k) {
+      var val = JSON.stringify(conf[k])
+      if (conf[k] !== npm.config.get(k)) {
+        if (!long) return
+        msg += '; ' + k + ' = ' + val + ' (overridden)\n'
+      } else msg += k + ' = ' + val + '\n'
+    })
+    msg += '\n'
+  }
+
+  return msg
+}
+
+function list (cb) {
+  var msg = ''
+  var long = npm.config.get('long')
+
+  var cli = npm.config.sources.cli.data
+  var cliKeys = getKeys(cli)
+  if (cliKeys.length) {
+    msg += '; cli configs\n'
+    cliKeys.forEach(function (k) {
+      if (cli[k] && typeof cli[k] === 'object') return
+      if (k === 'argv') return
+      msg += k + ' = ' + JSON.stringify(cli[k]) + '\n'
+    })
+    msg += '\n'
+  }
+
+  // env configs
+  msg += listFromSource('environment configs', npm.config.sources.env.data, long)
+
+  // project config file
+  var project = npm.config.sources.project
+  msg += listFromSource('project config ' + project.path, project.data, long)
+
+  // user config file
+  msg += listFromSource('userconfig ' + npm.config.get('userconfig'), npm.config.sources.user.data, long)
+
+  // global config file
+  msg += listFromSource('globalconfig ' + npm.config.get('globalconfig'), npm.config.sources.global.data, long)
+
+  // builtin config file
+  var builtin = npm.config.sources.builtin || {}
+  if (builtin && builtin.data) {
+    msg += listFromSource('builtin config ' + builtin.path, builtin.data, long)
+  }
+
+  // only show defaults if --long
+  if (!long) {
+    msg += '; node bin location = ' + process.execPath + '\n' +
+           '; cwd = ' + process.cwd() + '\n' +
+           '; HOME = ' + process.env.HOME + '\n' +
+           '; "npm config ls -l" to show all defaults.\n'
+
+    output(msg)
+    return cb()
+  }
+
+  var defaults = npmconf.defaults
+  var defKeys = getKeys(defaults)
+  msg += '; default values\n'
+  defKeys.forEach(function (k) {
+    if (defaults[k] && typeof defaults[k] === 'object') return
+    var val = JSON.stringify(defaults[k])
+    if (defaults[k] !== npm.config.get(k)) {
+      msg += '; ' + k + ' = ' + val + ' (overridden)\n'
+    } else msg += k + ' = ' + val + '\n'
+  })
+  msg += '\n'
+
+  output(msg)
+  return cb()
+}
+
+function unknown (action, cb) {
+  cb('Usage:\n' + config.usage)
+}