jfrog-cli-v2-jf 2.6.0

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

@@ -0,0 +1,430 @@
+// defaults, types, and shorthands.
+
+var path = require('path')
+var url = require('url')
+var Stream = require('stream').Stream
+var semver = require('semver')
+var stableFamily = semver.parse(process.version)
+var nopt = require('nopt')
+var os = require('os')
+var osenv = require('osenv')
+var umask = require('../utils/umask')
+var hasUnicode = require('has-unicode')
+
+var log
+try {
+  log = require('npmlog')
+} catch (er) {
+  var util = require('util')
+  log = { warn: function (m) {
+    console.warn(m + ' ' + util.format.apply(util, [].slice.call(arguments, 1)))
+  } }
+}
+
+exports.Umask = Umask
+function Umask () {}
+function validateUmask (data, k, val) {
+  return umask.validate(data, k, val)
+}
+
+function validateSemver (data, k, val) {
+  if (!semver.valid(val)) return false
+  data[k] = semver.valid(val)
+}
+
+function validateStream (data, k, val) {
+  if (!(val instanceof Stream)) return false
+  data[k] = val
+}
+
+nopt.typeDefs.semver = { type: semver, validate: validateSemver }
+nopt.typeDefs.Stream = { type: Stream, validate: validateStream }
+nopt.typeDefs.Umask = { type: Umask, validate: validateUmask }
+
+nopt.invalidHandler = function (k, val, type) {
+  log.warn('invalid config', k + '=' + JSON.stringify(val))
+
+  if (Array.isArray(type)) {
+    if (type.indexOf(url) !== -1) type = url
+    else if (type.indexOf(path) !== -1) type = path
+  }
+
+  switch (type) {
+    case Umask:
+      log.warn('invalid config', 'Must be umask, octal number in range 0000..0777')
+      break
+    case url:
+      log.warn('invalid config', "Must be a full url with 'http://'")
+      break
+    case path:
+      log.warn('invalid config', 'Must be a valid filesystem path')
+      break
+    case Number:
+      log.warn('invalid config', 'Must be a numeric value')
+      break
+    case Stream:
+      log.warn('invalid config', 'Must be an instance of the Stream class')
+      break
+  }
+}
+
+if (!stableFamily || (+stableFamily.minor % 2)) stableFamily = null
+else stableFamily = stableFamily.major + '.' + stableFamily.minor
+
+var defaults
+
+var temp = osenv.tmpdir()
+var home = osenv.home()
+
+var uidOrPid = process.getuid ? process.getuid() : process.pid
+
+if (home) process.env.HOME = home
+else home = path.resolve(temp, 'npm-' + uidOrPid)
+
+var cacheExtra = process.platform === 'win32' ? 'npm-cache' : '.npm'
+var cacheRoot = process.platform === 'win32' && process.env.APPDATA || home
+var cache = path.resolve(cacheRoot, cacheExtra)
+
+var globalPrefix
+Object.defineProperty(exports, 'defaults', {get: function () {
+  if (defaults) return defaults
+
+  if (process.env.PREFIX) {
+    globalPrefix = process.env.PREFIX
+  } else if (process.platform === 'win32') {
+    // c:\node\node.exe --> prefix=c:\node\
+    globalPrefix = path.dirname(process.execPath)
+  } else {
+    // /usr/local/bin/node --> prefix=/usr/local
+    globalPrefix = path.dirname(path.dirname(process.execPath))
+
+    // destdir only is respected on Unix
+    if (process.env.DESTDIR) {
+      globalPrefix = path.join(process.env.DESTDIR, globalPrefix)
+    }
+  }
+
+  defaults = {
+    access: null,
+    'allow-same-version': false,
+    'always-auth': false,
+    also: null,
+    'auth-type': 'legacy',
+
+    'bin-links': true,
+    browser: null,
+
+    ca: null,
+    cafile: null,
+
+    cache: cache,
+
+    'cache-lock-stale': 60000,
+    'cache-lock-retries': 10,
+    'cache-lock-wait': 10000,
+
+    'cache-max': Infinity,
+    'cache-min': 10,
+
+    cert: null,
+
+    cidr: null,
+
+    color: true,
+    depth: Infinity,
+    description: true,
+    dev: false,
+    'dry-run': false,
+    editor: osenv.editor(),
+    'engine-strict': false,
+    force: false,
+
+    'fetch-retries': 2,
+    'fetch-retry-factor': 10,
+    'fetch-retry-mintimeout': 10000,
+    'fetch-retry-maxtimeout': 60000,
+
+    git: 'git',
+    'git-tag-version': true,
+    'commit-hooks': true,
+
+    global: false,
+    globalconfig: path.resolve(globalPrefix, 'etc', 'npmrc'),
+    'global-style': false,
+    group: process.platform === 'win32' ? 0
+            : process.env.SUDO_GID || (process.getgid && process.getgid()),
+    'ham-it-up': false,
+    heading: 'npm',
+    'if-present': false,
+    'ignore-prepublish': false,
+    'ignore-scripts': false,
+    'init-module': path.resolve(home, '.npm-init.js'),
+    'init-author-name': '',
+    'init-author-email': '',
+    'init-author-url': '',
+    'init-version': '1.0.0',
+    'init-license': 'ISC',
+    json: false,
+    key: null,
+    'legacy-bundling': false,
+    link: false,
+    'local-address': undefined,
+    loglevel: 'notice',
+    logstream: process.stderr,
+    'logs-max': 10,
+    long: false,
+    maxsockets: 50,
+    message: '%s',
+    'metrics-registry': null,
+    'node-options': null,
+    'node-version': process.version,
+    'offline': false,
+    'onload-script': false,
+    only: null,
+    optional: true,
+    otp: null,
+    'package-lock': true,
+    'package-lock-only': false,
+    parseable: false,
+    'prefer-offline': false,
+    'prefer-online': false,
+    prefix: globalPrefix,
+    production: process.env.NODE_ENV === 'production',
+    'progress': !process.env.TRAVIS && !process.env.CI,
+    proxy: null,
+    'https-proxy': null,
+    'user-agent': 'npm/{npm-version} ' +
+                    'node/{node-version} ' +
+                    '{platform} ' +
+                    '{arch}',
+    'read-only': false,
+    'rebuild-bundle': true,
+    registry: 'https://registry.npmjs.org/',
+    rollback: true,
+    save: true,
+    'save-bundle': false,
+    'save-dev': false,
+    'save-exact': false,
+    'save-optional': false,
+    'save-prefix': '^',
+    'save-prod': false,
+    scope: '',
+    'script-shell': null,
+    'scripts-prepend-node-path': 'warn-only',
+    searchopts: '',
+    searchexclude: null,
+    searchlimit: 20,
+    searchstaleness: 15 * 60,
+    'send-metrics': false,
+    shell: osenv.shell(),
+    shrinkwrap: true,
+    'sign-git-tag': false,
+    'sso-poll-frequency': 500,
+    'sso-type': 'oauth',
+    'strict-ssl': true,
+    tag: 'latest',
+    'tag-version-prefix': 'v',
+    timing: false,
+    tmp: temp,
+    unicode: hasUnicode(),
+    'unsafe-perm': process.platform === 'win32' ||
+                     process.platform === 'cygwin' ||
+                     !(process.getuid && process.setuid &&
+                       process.getgid && process.setgid) ||
+                     process.getuid() !== 0,
+    usage: false,
+    user: process.platform === 'win32' ? 0 : 'nobody',
+    userconfig: path.resolve(home, '.npmrc'),
+    umask: process.umask ? process.umask() : umask.fromString('022'),
+    version: false,
+    versions: false,
+    viewer: process.platform === 'win32' ? 'browser' : 'man',
+
+    _exit: true
+  }
+
+  return defaults
+}})
+
+exports.types = {
+  access: [null, 'restricted', 'public'],
+  'allow-same-version': Boolean,
+  'always-auth': Boolean,
+  also: [null, 'dev', 'development'],
+  'auth-type': ['legacy', 'sso', 'saml', 'oauth'],
+  'bin-links': Boolean,
+  browser: [null, String],
+  ca: [null, String, Array],
+  cafile: path,
+  cache: path,
+  'cache-lock-stale': Number,
+  'cache-lock-retries': Number,
+  'cache-lock-wait': Number,
+  'cache-max': Number,
+  'cache-min': Number,
+  cert: [null, String],
+  cidr: [null, String, Array],
+  color: ['always', Boolean],
+  depth: Number,
+  description: Boolean,
+  dev: Boolean,
+  'dry-run': Boolean,
+  editor: String,
+  'engine-strict': Boolean,
+  force: Boolean,
+  'fetch-retries': Number,
+  'fetch-retry-factor': Number,
+  'fetch-retry-mintimeout': Number,
+  'fetch-retry-maxtimeout': Number,
+  git: String,
+  'git-tag-version': Boolean,
+  'commit-hooks': Boolean,
+  global: Boolean,
+  globalconfig: path,
+  'global-style': Boolean,
+  group: [Number, String],
+  'https-proxy': [null, url],
+  'user-agent': String,
+  'ham-it-up': Boolean,
+  'heading': String,
+  'if-present': Boolean,
+  'ignore-prepublish': Boolean,
+  'ignore-scripts': Boolean,
+  'init-module': path,
+  'init-author-name': String,
+  'init-author-email': String,
+  'init-author-url': ['', url],
+  'init-license': String,
+  'init-version': semver,
+  json: Boolean,
+  key: [null, String],
+  'legacy-bundling': Boolean,
+  link: Boolean,
+  // local-address must be listed as an IP for a local network interface
+  // must be IPv4 due to node bug
+  'local-address': getLocalAddresses(),
+  loglevel: ['silent', 'error', 'warn', 'notice', 'http', 'timing', 'info', 'verbose', 'silly'],
+  logstream: Stream,
+  'logs-max': Number,
+  long: Boolean,
+  maxsockets: Number,
+  message: String,
+  'metrics-registry': [null, String],
+  'node-options': [null, String],
+  'node-version': [null, semver],
+  offline: Boolean,
+  'onload-script': [null, String],
+  only: [null, 'dev', 'development', 'prod', 'production'],
+  optional: Boolean,
+  'package-lock': Boolean,
+  otp: Number,
+  'package-lock-only': Boolean,
+  parseable: Boolean,
+  'prefer-offline': Boolean,
+  'prefer-online': Boolean,
+  prefix: path,
+  production: Boolean,
+  progress: Boolean,
+  proxy: [null, false, url], // allow proxy to be disabled explicitly
+  'read-only': Boolean,
+  'rebuild-bundle': Boolean,
+  registry: [null, url],
+  rollback: Boolean,
+  save: Boolean,
+  'save-bundle': Boolean,
+  'save-dev': Boolean,
+  'save-exact': Boolean,
+  'save-optional': Boolean,
+  'save-prefix': String,
+  'save-prod': Boolean,
+  scope: String,
+  'script-shell': [null, String],
+  'scripts-prepend-node-path': [false, true, 'auto', 'warn-only'],
+  searchopts: String,
+  searchexclude: [null, String],
+  searchlimit: Number,
+  searchstaleness: Number,
+  'send-metrics': Boolean,
+  shell: String,
+  shrinkwrap: Boolean,
+  'sign-git-tag': Boolean,
+  'sso-poll-frequency': Number,
+  'sso-type': [null, 'oauth', 'saml'],
+  'strict-ssl': Boolean,
+  tag: String,
+  timing: Boolean,
+  tmp: path,
+  unicode: Boolean,
+  'unsafe-perm': Boolean,
+  usage: Boolean,
+  user: [Number, String],
+  userconfig: path,
+  umask: Umask,
+  version: Boolean,
+  'tag-version-prefix': String,
+  versions: Boolean,
+  viewer: String,
+  _exit: Boolean
+}
+
+function getLocalAddresses () {
+  var interfaces
+  // #8094: some environments require elevated permissions to enumerate
+  // interfaces, and synchronously throw EPERM when run without
+  // elevated privileges
+  try {
+    interfaces = os.networkInterfaces()
+  } catch (e) {
+    interfaces = {}
+  }
+
+  return Object.keys(interfaces).map(function (nic) {
+    return interfaces[nic].filter(function (addr) {
+      return addr.family === 'IPv4'
+    })
+    .map(function (addr) {
+      return addr.address
+    })
+  }).reduce(function (curr, next) {
+    return curr.concat(next)
+  }, []).concat(undefined)
+}
+
+exports.shorthands = {
+  s: ['--loglevel', 'silent'],
+  d: ['--loglevel', 'info'],
+  dd: ['--loglevel', 'verbose'],
+  ddd: ['--loglevel', 'silly'],
+  noreg: ['--no-registry'],
+  N: ['--no-registry'],
+  reg: ['--registry'],
+  'no-reg': ['--no-registry'],
+  silent: ['--loglevel', 'silent'],
+  verbose: ['--loglevel', 'verbose'],
+  quiet: ['--loglevel', 'warn'],
+  q: ['--loglevel', 'warn'],
+  h: ['--usage'],
+  H: ['--usage'],
+  '?': ['--usage'],
+  help: ['--usage'],
+  v: ['--version'],
+  f: ['--force'],
+  desc: ['--description'],
+  'no-desc': ['--no-description'],
+  'local': ['--no-global'],
+  l: ['--long'],
+  m: ['--message'],
+  p: ['--parseable'],
+  porcelain: ['--parseable'],
+  readonly: ['--read-only'],
+  g: ['--global'],
+  S: ['--save'],
+  D: ['--save-dev'],
+  E: ['--save-exact'],
+  O: ['--save-optional'],
+  P: ['--save-prod'],
+  y: ['--yes'],
+  n: ['--no-yes'],
+  B: ['--save-bundle'],
+  C: ['--prefix']
+}

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

@@ -0,0 +1,77 @@
+'use strict'
+
+const url = require('url')
+
+module.exports.fromPacote = fromPacote
+
+function fromPacote (opts) {
+  return {
+    cache: getCacheMode(opts),
+    cacheManager: opts.cache,
+    ca: opts.ca,
+    cert: opts.cert,
+    headers: getHeaders('', opts.registry, opts),
+    key: opts.key,
+    localAddress: opts.localAddress,
+    maxSockets: opts.maxSockets,
+    proxy: opts.proxy,
+    referer: opts.refer,
+    retry: opts.retry,
+    strictSSL: !!opts.strictSSL,
+    timeout: opts.timeout,
+    uid: opts.uid,
+    gid: opts.gid
+  }
+}
+
+function getCacheMode (opts) {
+  return opts.offline
+  ? 'only-if-cached'
+  : opts.preferOffline
+  ? 'force-cache'
+  : opts.preferOnline
+  ? 'no-cache'
+  : 'default'
+}
+
+function getHeaders (uri, registry, opts) {
+  const headers = Object.assign({
+    'npm-in-ci': opts.isFromCI,
+    'npm-scope': opts.projectScope,
+    'npm-session': opts.npmSession,
+    'user-agent': opts.userAgent,
+    'referer': opts.refer
+  }, opts.headers)
+  // check for auth settings specific to this registry
+  let auth = (
+    opts.auth &&
+    opts.auth[registryKey(registry)]
+  ) || opts.auth
+  // If a tarball is hosted on a different place than the manifest, only send
+  // credentials on `alwaysAuth`
+  const shouldAuth = auth && (
+    auth.alwaysAuth ||
+    url.parse(uri).host === url.parse(registry).host
+  )
+  if (shouldAuth && auth.token) {
+    headers.authorization = `Bearer ${auth.token}`
+  } else if (shouldAuth && auth.username && auth.password) {
+    const encoded = Buffer.from(
+      `${auth.username}:${auth.password}`, 'utf8'
+    ).toString('base64')
+    headers.authorization = `Basic ${encoded}`
+  } else if (shouldAuth && auth._auth) {
+    headers.authorization = `Basic ${auth._auth}`
+  }
+  return headers
+}
+
+function registryKey (registry) {
+  const parsed = url.parse(registry)
+  const formatted = url.format({
+    host: parsed.host,
+    pathname: parsed.pathname,
+    slashes: parsed.slashes
+  })
+  return url.resolve(formatted, '.')
+}

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

@@ -0,0 +1,32 @@
+'use strict'
+
+const npm = require('../npm.js')
+const log = require('npmlog')
+
+module.exports = gentleFSOpts
+
+function gentleFSOpts (gently, base, abs) {
+  return {
+    // never rm the root, prefix, or bin dirs
+    //
+    // globals included because of `npm link` -- as far as the package
+    // requesting the link is concerned, the linked package is always
+    // installed globally
+    prefixes: [
+      npm.prefix,
+      npm.globalPrefix,
+      npm.dir,
+      npm.root,
+      npm.globalDir,
+      npm.bin,
+      npm.globalBin
+    ],
+    absolute: abs,
+    log: log,
+    prefix: npm.prefix,
+    force: npm.config.get('force'),
+    gently: gently,
+    base: base,
+    name: 'npm'
+  }
+}

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

@@ -0,0 +1,72 @@
+var assert = require('assert')
+
+var toNerfDart = require('./nerf-dart.js')
+
+module.exports = getCredentialsByURI
+
+function getCredentialsByURI (uri) {
+  assert(uri && typeof uri === 'string', 'registry URL is required')
+  var nerfed = toNerfDart(uri)
+  var defnerf = toNerfDart(this.get('registry'))
+
+  // hidden class micro-optimization
+  var c = {
+    scope: nerfed,
+    token: undefined,
+    password: undefined,
+    username: undefined,
+    email: undefined,
+    auth: undefined,
+    alwaysAuth: undefined
+  }
+
+  // used to override scope matching for tokens as well as legacy auth
+  if (this.get(nerfed + ':always-auth') !== undefined) {
+    var val = this.get(nerfed + ':always-auth')
+    c.alwaysAuth = val === 'false' ? false : !!val
+  } else if (this.get('always-auth') !== undefined) {
+    c.alwaysAuth = this.get('always-auth')
+  }
+
+  if (this.get(nerfed + ':_authToken')) {
+    c.token = this.get(nerfed + ':_authToken')
+    // the bearer token is enough, don't confuse things
+    return c
+  }
+
+  // Handle the old-style _auth=<base64> style for the default
+  // registry, if set.
+  var authDef = this.get('_auth')
+  var userDef = this.get('username')
+  var passDef = this.get('_password')
+  if (authDef && !(userDef && passDef)) {
+    authDef = new Buffer(authDef, 'base64').toString()
+    authDef = authDef.split(':')
+    userDef = authDef.shift()
+    passDef = authDef.join(':')
+  }
+
+  if (this.get(nerfed + ':_password')) {
+    c.password = new Buffer(this.get(nerfed + ':_password'), 'base64').toString('utf8')
+  } else if (nerfed === defnerf && passDef) {
+    c.password = passDef
+  }
+
+  if (this.get(nerfed + ':username')) {
+    c.username = this.get(nerfed + ':username')
+  } else if (nerfed === defnerf && userDef) {
+    c.username = userDef
+  }
+
+  if (this.get(nerfed + ':email')) {
+    c.email = this.get(nerfed + ':email')
+  } else if (this.get('email')) {
+    c.email = this.get('email')
+  }
+
+  if (c.username && c.password) {
+    c.auth = new Buffer(c.username + ':' + c.password).toString('base64')
+  }
+
+  return c
+}

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

@@ -0,0 +1,31 @@
+'use strict'
+
+const npm = require('../npm.js')
+const log = require('npmlog')
+
+module.exports = lifecycleOpts
+
+let opts
+
+function lifecycleOpts (moreOpts) {
+  if (!opts) {
+    opts = {
+      config: npm.config.snapshot,
+      dir: npm.dir,
+      failOk: false,
+      force: npm.config.get('force'),
+      group: npm.config.get('group'),
+      ignorePrepublish: npm.config.get('ignore-prepublish'),
+      ignoreScripts: npm.config.get('ignore-scripts'),
+      log: log,
+      nodeOptions: npm.config.get('node-options'),
+      production: npm.config.get('production'),
+      scriptShell: npm.config.get('script-shell'),
+      scriptsPrependNodePath: npm.config.get('scripts-prepend-node-path'),
+      unsafePerm: npm.config.get('unsafe-perm'),
+      user: npm.config.get('user')
+    }
+  }
+
+  return moreOpts ? Object.assign({}, opts, moreOpts) : opts
+}

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

@@ -0,0 +1,32 @@
+module.exports = loadCAFile
+
+var fs = require('fs')
+
+function loadCAFile (cafilePath, cb) {
+  if (!cafilePath) return process.nextTick(cb)
+
+  fs.readFile(cafilePath, 'utf8', afterCARead.bind(this))
+
+  function afterCARead (er, cadata) {
+    if (er) {
+      // previous cafile no longer exists, so just continue on gracefully
+      if (er.code === 'ENOENT') return cb()
+      return cb(er)
+    }
+
+    var delim = '-----END CERTIFICATE-----'
+    var output
+
+    output = cadata
+      .split(delim)
+      .filter(function (xs) {
+        return !!xs.trim()
+      })
+      .map(function (xs) {
+        return xs.trimLeft() + delim
+      })
+
+    this.set('ca', output)
+    cb(null)
+  }
+}