jfrog-cli-v2-jf 2.6.0

package/node-v8.11.1-linux-x64/lib/node_modules/npm/lib/utils/error-message.js

@@ -0,0 +1,335 @@
+'use strict'
+var npm = require('../npm.js')
+var util = require('util')
+var nameValidator = require('validate-npm-package-name')
+
+module.exports = errorMessage
+
+function errorMessage (er) {
+  var short = []
+  var detail = []
+  switch (er.code) {
+    case 'ECONNREFUSED':
+      short.push(['', er])
+      detail.push([
+        '',
+        [
+          '\nIf you are behind a proxy, please make sure that the',
+          "'proxy' config is set properly.  See: 'npm help config'"
+        ].join('\n')
+      ])
+      break
+
+    case 'EACCES':
+    case 'EPERM':
+      short.push(['', er])
+      detail.push(['', ['\nPlease try running this command again as root/Administrator.'
+                ].join('\n')])
+      break
+
+    case 'ELIFECYCLE':
+      short.push(['', er.message])
+      detail.push([
+        '',
+        [
+          '',
+          'Failed at the ' + er.pkgid + ' ' + er.stage + ' script.',
+          'This is probably not a problem with npm. There is likely additional logging output above.'
+        ].join('\n')]
+      )
+      break
+
+    case 'ENOGIT':
+      short.push(['', er.message])
+      detail.push([
+        '',
+        [
+          '',
+          'Failed using git.',
+          'Please check if you have git installed and in your PATH.'
+        ].join('\n')
+      ])
+      break
+
+    case 'EJSONPARSE':
+      short.push(['', er.message])
+      short.push(['', 'File: ' + er.file])
+      detail.push([
+        '',
+        [
+          'Failed to parse package.json data.',
+          'package.json must be actual JSON, not just JavaScript.',
+          '',
+          'Tell the package author to fix their package.json file.'
+        ].join('\n'),
+        'JSON.parse'
+      ])
+      break
+
+    case 'EOTP':
+    case 'E401':
+      // the E401 message checking is a hack till we replace npm-registry-client with something
+      // OTP aware.
+      if (er.code === 'EOTP' || (er.code === 'E401' && /one-time pass/.test(er.message))) {
+        short.push(['', 'This operation requires a one-time password from your authenticator.'])
+        detail.push([
+          '',
+          [
+            'You can provide a one-time password by passing --otp=<code> to the command you ran.',
+            'If you already provided a one-time password then it is likely that you either typoed',
+            'it, or it timed out. Please try again.'
+          ].join('\n')
+        ])
+        break
+      } else {
+        // npm ERR! code E401
+        // npm ERR! Unable to authenticate, need: Basic
+        if (er.headers && er.headers['www-authenticate']) {
+          const auth = er.headers['www-authenticate'].map((au) => au.split(/,\s*/))[0] || []
+          if (auth.indexOf('Bearer') !== -1) {
+            short.push(['', 'Unable to authenticate, your authentication token seems to be invalid.'])
+            detail.push([
+              '',
+              [
+                'To correct this please trying logging in again with:',
+                '    npm login'
+              ].join('\n')
+            ])
+            break
+          } else if (auth.indexOf('Basic') !== -1) {
+            short.push(['', 'Incorrect or missing password.'])
+            detail.push([
+              '',
+              [
+                'If you were trying to login, change your password, create an',
+                'authentication token or enable two-factor authentication then',
+                'that means you likely typed your password in incorrectly.',
+                'Please try again, or recover your password at:',
+                '    https://www.npmjs.com/forgot',
+                '',
+                'If you were doing some other operation then your saved credentials are',
+                'probably out of date. To correct this please try logging in again with:',
+                '    npm login'
+              ].join('\n')
+            ])
+            break
+          }
+        }
+      }
+
+    case 'E404':
+      // There's no need to have 404 in the message as well.
+      var msg = er.message.replace(/^404\s+/, '')
+      short.push(['404', msg])
+      if (er.pkgid && er.pkgid !== '-') {
+        detail.push(['404', ''])
+        detail.push(['404', '', "'" + er.pkgid + "' is not in the npm registry."])
+
+        var valResult = nameValidator(er.pkgid)
+
+        if (valResult.validForNewPackages) {
+          detail.push(['404', 'You should bug the author to publish it (or use the name yourself!)'])
+        } else {
+          detail.push(['404', 'Your package name is not valid, because', ''])
+
+          var errorsArray = (valResult.errors || []).concat(valResult.warnings || [])
+          errorsArray.forEach(function (item, idx) {
+            detail.push(['404', ' ' + (idx + 1) + '. ' + item])
+          })
+        }
+
+        if (er.parent) {
+          detail.push(['404', "It was specified as a dependency of '" + er.parent + "'"])
+        }
+        detail.push(['404', '\nNote that you can also install from a'])
+        detail.push(['404', 'tarball, folder, http url, or git url.'])
+      }
+      break
+
+    case 'EPUBLISHCONFLICT':
+      short.push(['publish fail', 'Cannot publish over existing version.'])
+      detail.push(['publish fail', "Update the 'version' field in package.json and try again."])
+      detail.push(['publish fail', ''])
+      detail.push(['publish fail', 'To automatically increment version numbers, see:'])
+      detail.push(['publish fail', '    npm help version'])
+      break
+
+    case 'EISGIT':
+      short.push(['git', er.message])
+      short.push(['git', '    ' + er.path])
+      detail.push([
+        'git',
+        [
+          'Refusing to remove it. Update manually,',
+          'or move it out of the way first.'
+        ].join('\n')
+      ])
+      break
+
+    case 'ECYCLE':
+      short.push([
+        'cycle',
+        [
+          er.message,
+          'While installing: ' + er.pkgid
+        ].join('\n')
+      ])
+      detail.push([
+        'cycle',
+        [
+          'Found a pathological dependency case that npm cannot solve.',
+          'Please report this to the package author.'
+        ].join('\n')
+      ])
+      break
+
+    case 'EBADPLATFORM':
+      var validOs = er.os.join ? er.os.join(',') : er.os
+      var validArch = er.cpu.join ? er.cpu.join(',') : er.cpu
+      var expected = {os: validOs, arch: validArch}
+      var actual = {os: process.platform, arch: process.arch}
+      short.push([
+        'notsup',
+        [
+          util.format('Unsupported platform for %s: wanted %j (current: %j)', er.pkgid, expected, actual)
+        ].join('\n')
+      ])
+      detail.push([
+        'notsup',
+        [
+          'Valid OS:    ' + validOs,
+          'Valid Arch:  ' + validArch,
+          'Actual OS:   ' + process.platform,
+          'Actual Arch: ' + process.arch
+        ].join('\n')
+      ])
+      break
+
+    case 'EEXIST':
+      short.push(['', er.message])
+      short.push(['', 'File exists: ' + er.path])
+      detail.push(['', 'Move it away, and try again.'])
+      break
+
+    case 'ENEEDAUTH':
+      short.push(['need auth', er.message])
+      detail.push(['need auth', 'You need to authorize this machine using `npm adduser`'])
+      break
+
+    case 'ECONNRESET':
+    case 'ENOTFOUND':
+    case 'ETIMEDOUT':
+    case 'EAI_FAIL':
+      short.push(['network', er.message])
+      detail.push([
+        'network',
+        [
+          'This is a problem related to network connectivity.',
+          'In most cases you are behind a proxy or have bad network settings.',
+          '\nIf you are behind a proxy, please make sure that the',
+          "'proxy' config is set properly.  See: 'npm help config'"
+        ].join('\n')
+      ])
+      break
+
+    case 'ENOPACKAGEJSON':
+      short.push(['package.json', er.message])
+      detail.push([
+        'package.json',
+        [
+          "npm can't find a package.json file in your current directory."
+        ].join('\n')
+      ])
+      break
+
+    case 'ETARGET':
+      short.push(['notarget', er.message])
+      msg = [
+        'In most cases you or one of your dependencies are requesting',
+        "a package version that doesn't exist."
+      ]
+      if (er.parent) {
+        msg.push("\nIt was specified as a dependency of '" + er.parent + "'\n")
+      }
+      detail.push(['notarget', msg.join('\n')])
+      break
+
+    case 'ENOTSUP':
+      if (er.required) {
+        short.push(['notsup', er.message])
+        short.push(['notsup', 'Not compatible with your version of node/npm: ' + er.pkgid])
+        detail.push([
+          'notsup',
+          [
+            'Not compatible with your version of node/npm: ' + er.pkgid,
+            'Required: ' + JSON.stringify(er.required),
+            'Actual:   ' + JSON.stringify({
+              npm: npm.version,
+              node: npm.config.get('node-version')
+            })
+          ].join('\n')
+        ])
+        break
+      } // else passthrough
+      /*eslint no-fallthrough:0*/
+
+    case 'ENOSPC':
+      short.push(['nospc', er.message])
+      detail.push([
+        'nospc',
+        [
+          'There appears to be insufficient space on your system to finish.',
+          'Clear up some disk space and try again.'
+        ].join('\n')
+      ])
+      break
+
+    case 'EROFS':
+      short.push(['rofs', er.message])
+      detail.push([
+        'rofs',
+        [
+          'Often virtualized file systems, or other file systems',
+          "that don't support symlinks, give this error."
+        ].join('\n')
+      ])
+      break
+
+    case 'ENOENT':
+      short.push(['enoent', er.message])
+      detail.push([
+        'enoent',
+        [
+          'This is related to npm not being able to find a file.',
+          er.file ? "\nCheck if the file '" + er.file + "' is present." : ''
+        ].join('\n')
+      ])
+      break
+
+    case 'EMISSINGARG':
+    case 'EUNKNOWNTYPE':
+    case 'EINVALIDTYPE':
+    case 'ETOOMANYARGS':
+      short.push(['typeerror', er.stack])
+      detail.push([
+        'typeerror',
+        [
+          'This is an error with npm itself. Please report this error at:',
+          '    <https://github.com/npm/npm/issues>'
+        ].join('\n')
+      ])
+      break
+
+    default:
+      short.push(['', er.message || er])
+      break
+  }
+  if (er.optional) {
+    short.unshift(['optional', er.optional + ' (' + er.location + '):'])
+    short.concat(detail).forEach(function (msg) {
+      if (!msg[0]) msg[0] = 'optional'
+      if (msg[1]) msg[1] = msg[1].toString().replace(/(^|\n)/g, '$1SKIPPING OPTIONAL DEPENDENCY: ')
+    })
+  }
+  return {summary: short, detail: detail}
+}

package/node-v8.11.1-linux-x64/lib/node_modules/npm/lib/utils/escape-arg.js

@@ -0,0 +1,27 @@
+'use strict'
+var path = require('path')
+var isWindowsShell = require('./is-windows-shell.js')
+
+/*
+Escape the name of an executable suitable for passing to the system shell.
+
+Windows is easy, wrap in double quotes and you're done, as there's no
+facility to create files with quotes in their names.
+
+Unix-likes are a little more complicated, wrap in single quotes and escape
+any single quotes in the filename.
+*/
+
+module.exports = escapify
+
+function escapify (str) {
+  if (isWindowsShell) {
+    return '"' + path.normalize(str) + '"'
+  } else {
+    if (/[^-_.~/\w]/.test(str)) {
+      return "'" + str.replace(/'/g, "'\"'\"'") + "'"
+    } else {
+      return str
+    }
+  }
+}

package/node-v8.11.1-linux-x64/lib/node_modules/npm/lib/utils/escape-exec-path.js

@@ -0,0 +1,30 @@
+'use strict'
+var path = require('path')
+var isWindowsShell = require('./is-windows-shell.js')
+
+/*
+Escape the name of an executable suitable for passing to the system shell.
+
+Windows is easy, wrap in double quotes and you're done, as there's no
+facility to create files with quotes in their names.
+
+Unix-likes are a little more complicated, wrap in single quotes and escape
+any single quotes in the filename.
+*/
+
+module.exports = escapify
+
+function windowsQuotes (str) {
+  if (!/ /.test(str)) return str
+  return '"' + str + '"'
+}
+
+function escapify (str) {
+  if (isWindowsShell) {
+    return path.normalize(str).split(/\\/).map(windowsQuotes).join('\\')
+  } else if (/[^-_.~/\w]/.test(str)) {
+    return "'" + str.replace(/'/g, "'\"'\"'") + "'"
+  } else {
+    return str
+  }
+}

package/node-v8.11.1-linux-x64/lib/node_modules/npm/lib/utils/gently-rm.js

@@ -0,0 +1,21 @@
+// only remove the thing if it's a symlink into a specific folder. This is
+// a very common use-case of npm's, but not so common elsewhere.
+
+exports = module.exports = gentlyRm
+
+var gentleFS = require('gentle-fs')
+var gentleFSOpts = require('../config/gentle-fs.js')
+
+function gentlyRm (target, gently, base, cb) {
+  if (!cb) {
+    cb = base
+    base = undefined
+  }
+
+  if (!cb) {
+    cb = gently
+    gently = false
+  }
+
+  return gentleFS.rm(target, gentleFSOpts(gently, base), cb)
+}

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

@@ -0,0 +1,29 @@
+'use strict'
+
+const clientConfig = require('../config/reg-client.js')
+const Conf = require('../config/core.js').Conf
+const log = require('npmlog')
+const npm = require('../npm.js')
+const RegClient = require('npm-registry-client')
+
+module.exports = getPublishConfig
+
+function getPublishConfig (publishConfig, defaultConfig, defaultClient) {
+  let config = defaultConfig
+  let client = defaultClient
+  log.verbose('getPublishConfig', publishConfig)
+  if (publishConfig) {
+    config = new Conf(defaultConfig)
+    config.save = defaultConfig.save.bind(defaultConfig)
+
+    // don't modify the actual publishConfig object, in case we have
+    // to set a login token or some other data.
+    config.unshift(Object.keys(publishConfig).reduce(function (s, k) {
+      s[k] = publishConfig[k]
+      return s
+    }, {}))
+    client = new RegClient(clientConfig(npm, log, config))
+  }
+
+  return { config: config, client: client }
+}

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

@@ -0,0 +1,50 @@
+'use strict'
+
+const BB = require('bluebird')
+
+const exec = require('child_process').execFile
+const spawn = require('./spawn')
+const npm = require('../npm.js')
+const which = require('which')
+const git = npm.config.get('git')
+const assert = require('assert')
+const log = require('npmlog')
+const noProgressTillDone = require('./no-progress-while-running.js').tillDone
+
+exports.spawn = spawnGit
+exports.exec = BB.promisify(execGit)
+exports.chainableExec = chainableExec
+exports.whichAndExec = whichAndExec
+
+function prefixGitArgs () {
+  return process.platform === 'win32' ? ['-c', 'core.longpaths=true'] : []
+}
+
+function execGit (args, options, cb) {
+  log.info('git', args)
+  const fullArgs = prefixGitArgs().concat(args || [])
+  return exec(git, fullArgs, options, noProgressTillDone(cb))
+}
+
+function spawnGit (args, options) {
+  log.info('git', args)
+  return spawn(git, prefixGitArgs().concat(args || []), options)
+}
+
+function chainableExec () {
+  var args = Array.prototype.slice.call(arguments)
+  return [execGit].concat(args)
+}
+
+function whichAndExec (args, options, cb) {
+  assert.equal(typeof cb, 'function', 'no callback provided')
+  // check for git
+  which(git, function (err) {
+    if (err) {
+      err.code = 'ENOGIT'
+      return cb(err)
+    }
+
+    execGit(args, options, cb)
+  })
+}

package/node-v8.11.1-linux-x64/lib/node_modules/npm/lib/utils/gunzip-maybe.js

@@ -0,0 +1,22 @@
+var duplex = require('mississippi').duplex
+var through = require('mississippi').through
+var zlib = require('zlib')
+
+function hasGzipHeader (c) {
+  return c[0] === 0x1F && c[1] === 0x8B && c[2] === 0x08
+}
+
+module.exports = gunzip
+function gunzip () {
+  var stream = duplex()
+  var peeker = through(function (chunk, enc, cb) {
+    var newStream = hasGzipHeader(chunk)
+    ? zlib.createGunzip()
+    : through()
+    stream.setReadable(newStream)
+    stream.setWritable(newStream)
+    stream.write(chunk)
+  })
+  stream.setWritable(peeker)
+  return stream
+}

package/node-v8.11.1-linux-x64/lib/node_modules/npm/lib/utils/is-registry.js

@@ -0,0 +1,12 @@
+'use strict'
+module.exports = isRegistry
+
+function isRegistry (req) {
+  if (req == null) return false
+  // modern metadata
+  if ('registry' in req) return req.registry
+  // legacy metadata
+  if (req.type === 'range' || req.type === 'version' || req.type === 'tag') return true
+  return false
+}
+

package/node-v8.11.1-linux-x64/lib/node_modules/npm/lib/utils/is-windows-bash.js

@@ -0,0 +1,3 @@
+'use strict'
+var isWindows = require('./is-windows.js')
+module.exports = isWindows && /^MINGW(32|64)$/.test(process.env.MSYSTEM)

package/node-v8.11.1-linux-x64/lib/node_modules/npm/lib/utils/is-windows-shell.js

@@ -0,0 +1,4 @@
+'use strict'
+var isWindows = require('./is-windows.js')
+var isWindowsBash = require('./is-windows-bash.js')
+module.exports = isWindows && !isWindowsBash

package/node-v8.11.1-linux-x64/lib/node_modules/npm/lib/utils/is-windows.js

@@ -0,0 +1,2 @@
+'use strict'
+module.exports = process.platform === 'win32'

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

@@ -0,0 +1,18 @@
+exports = module.exports = cmd
+
+var npm = require('../npm.js')
+var usage = require('./usage.js')
+
+function cmd (stage) {
+  function CMD (args, cb) {
+    npm.commands['run-script']([stage].concat(args), cb)
+  }
+  CMD.usage = usage(stage, 'npm ' + stage + ' [-- <args>]')
+  var installedShallow = require('./completion/installed-shallow.js')
+  CMD.completion = function (opts, cb) {
+    installedShallow(opts, function (d) {
+      return d.scripts && d.scripts[stage]
+    }, cb)
+  }
+  return CMD
+}

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

@@ -0,0 +1,14 @@
+exports = module.exports = runLifecycle
+
+const lifecycleOpts = require('../config/lifecycle')
+const lifecycle = require('npm-lifecycle')
+
+function runLifecycle (pkg, stage, wd, moreOpts, cb) {
+  if (typeof moreOpts === 'function') {
+    cb = moreOpts
+    moreOpts = null
+  }
+
+  const opts = lifecycleOpts(moreOpts)
+  lifecycle(pkg, stage, wd, opts).then(cb, cb)
+}

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

@@ -0,0 +1,8 @@
+module.exports = link
+
+var gentleFS = require('gentle-fs')
+var gentleFSOpts = require('../config/gentle-fs.js')
+
+function link (from, to, gently, abs, cb) {
+  return gentleFS.link(from, to, gentleFSOpts(gently, undefined, abs), cb)
+}

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

@@ -0,0 +1,73 @@
+var crypto = require('crypto')
+var resolve = require('path').resolve
+
+var lockfile = require('lockfile')
+var log = require('npmlog')
+
+var npm = require('../npm.js')
+var correctMkdir = require('../utils/correct-mkdir.js')
+
+var installLocks = {}
+
+function lockFileName (base, name) {
+  var c = name.replace(/[^a-zA-Z0-9]+/g, '-').replace(/^-+|-+$/g, '')
+  var p = resolve(base, name)
+  var h = crypto.createHash('sha1').update(p).digest('hex')
+  var l = resolve(npm.cache, '_locks')
+
+  return resolve(l, c.substr(0, 24) + '-' + h.substr(0, 16) + '.lock')
+}
+
+function lock (base, name, cb) {
+  var lockDir = resolve(npm.cache, '_locks')
+  correctMkdir(lockDir, function (er) {
+    if (er) return cb(er)
+
+    var opts = {
+      stale: npm.config.get('cache-lock-stale'),
+      retries: npm.config.get('cache-lock-retries'),
+      wait: npm.config.get('cache-lock-wait')
+    }
+    var lf = lockFileName(base, name)
+    lockfile.lock(lf, opts, function (er) {
+      if (er) log.warn('locking', lf, 'failed', er)
+
+      if (!er) {
+        log.verbose('lock', 'using', lf, 'for', resolve(base, name))
+        installLocks[lf] = true
+      }
+
+      cb(er)
+    })
+  })
+}
+
+function unlock (base, name, cb) {
+  var lf = lockFileName(base, name)
+  var locked = installLocks[lf]
+  if (locked === false) {
+    return process.nextTick(cb)
+  } else if (locked === true) {
+    lockfile.unlock(lf, function (er) {
+      if (er) {
+        log.warn('unlocking', lf, 'failed', er)
+      } else {
+        installLocks[lf] = false
+        log.verbose('unlock', 'done using', lf, 'for', resolve(base, name))
+      }
+
+      cb(er)
+    })
+  } else {
+    var notLocked = new Error(
+      'Attempt to unlock ' + resolve(base, name) + ", which hasn't been locked"
+    )
+    notLocked.code = 'ENOTLOCKED'
+    throw notLocked
+  }
+}
+
+module.exports = {
+  lock: lock,
+  unlock: unlock
+}