jfrog-cli-v2-jf 2.6.0

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

@@ -0,0 +1,172 @@
+'use strict'
+
+const BB = require('bluebird')
+
+const cacache = require('cacache')
+const cacheKey = require('../util/cache-key')
+const Fetcher = require('../fetch')
+const git = require('../util/git')
+const mkdirp = BB.promisify(require('mkdirp'))
+const pickManifest = require('npm-pick-manifest')
+const optCheck = require('../util/opt-check')
+const osenv = require('osenv')
+const packDir = require('../util/pack-dir')
+const PassThrough = require('stream').PassThrough
+const path = require('path')
+const pipe = BB.promisify(require('mississippi').pipe)
+const rimraf = BB.promisify(require('rimraf'))
+const uniqueFilename = require('unique-filename')
+
+// `git` dependencies are fetched from git repositories and packed up.
+const fetchGit = module.exports = Object.create(null)
+
+Fetcher.impl(fetchGit, {
+  manifest (spec, opts) {
+    opts = optCheck(opts)
+    if (spec.hosted && spec.hosted.getDefaultRepresentation() === 'shortcut') {
+      return hostedManifest(spec, opts)
+    } else {
+      // If it's not a shortcut, don't do fallbacks.
+      return plainManifest(spec.fetchSpec, spec, opts)
+    }
+  },
+
+  tarball (spec, opts) {
+    opts = optCheck(opts)
+    const stream = new PassThrough()
+    this.manifest(spec, opts).then(manifest => {
+      stream.emit('manifest', manifest)
+      return pipe(
+        this.fromManifest(
+          manifest, spec, opts
+        ).on('integrity', i => stream.emit('integrity', i)), stream
+      )
+    }, err => stream.emit('error', err))
+    return stream
+  },
+
+  fromManifest (manifest, spec, opts) {
+    opts = optCheck(opts)
+    let streamError
+    const stream = new PassThrough().on('error', e => { streamError = e })
+    const cacheName = manifest._uniqueResolved || manifest._resolved || ''
+    const cacheStream = (
+      opts.cache &&
+      cacache.get.stream(
+        opts.cache, cacheKey('packed-dir', cacheName), opts
+      ).on('integrity', i => stream.emit('integrity', i))
+    )
+    cacheStream.pipe(stream)
+    cacheStream.on('error', err => {
+      if (err.code !== 'ENOENT') {
+        return stream.emit('error', err)
+      } else {
+        stream.emit('reset')
+        return withTmp(opts, tmp => {
+          if (streamError) { throw streamError }
+          return cloneRepo(
+            spec, manifest._repo, manifest._ref, manifest._rawRef, tmp, opts
+          ).then(HEAD => {
+            if (streamError) { throw streamError }
+            manifest._resolved = spec.saveSpec.replace(/(:?#.*)?$/, `#${HEAD}`)
+            manifest._uniqueResolved = manifest._resolved
+            return packDir(manifest, manifest._uniqueResolved, tmp, stream, opts)
+          })
+        }).catch(err => stream.emit('error', err))
+      }
+    })
+    return stream
+  }
+})
+
+function hostedManifest (spec, opts) {
+  return BB.resolve(null).then(() => {
+    if (!spec.hosted.git()) {
+      throw new Error(`No git url for ${spec}`)
+    }
+    return plainManifest(spec.hosted.git(), spec, opts)
+  }).catch(err => {
+    if (!spec.hosted.https()) {
+      throw err
+    }
+    return plainManifest(spec.hosted.https(), spec, opts)
+  }).catch(err => {
+    if (!spec.hosted.sshurl()) {
+      throw err
+    }
+    return plainManifest(spec.hosted.sshurl(), spec, opts)
+  })
+}
+
+function plainManifest (repo, spec, opts) {
+  const rawRef = spec.gitCommittish || spec.gitRange
+  return resolve(
+    repo, spec, spec.name, opts
+  ).then(ref => {
+    if (ref) {
+      const resolved = spec.saveSpec.replace(/(?:#.*)?$/, `#${ref.sha}`)
+      return {
+        _repo: repo,
+        _resolved: resolved,
+        _spec: spec,
+        _ref: ref,
+        _rawRef: spec.gitCommittish || spec.gitRange,
+        _uniqueResolved: resolved,
+        _integrity: false
+      }
+    } else {
+      // We're SOL and need a full clone :(
+      //
+      // If we're confident enough that `rawRef` is a commit SHA,
+      // then we can at least get `finalize-manifest` to cache its result.
+      const resolved = spec.saveSpec.replace(/(?:#.*)?$/, rawRef ? `#${rawRef}` : '')
+      return {
+        _repo: repo,
+        _rawRef: rawRef,
+        _resolved: rawRef && rawRef.match(/^[a-f0-9]{40}$/) && resolved,
+        _uniqueResolved: rawRef && rawRef.match(/^[a-f0-9]{40}$/) && resolved,
+        _integrity: false
+      }
+    }
+  })
+}
+
+function resolve (url, spec, name, opts) {
+  const isSemver = !!spec.gitRange
+  return git.revs(url, opts).then(remoteRefs => {
+    return isSemver
+    ? pickManifest({
+      versions: remoteRefs.versions,
+      'dist-tags': remoteRefs['dist-tags'],
+      name: name
+    }, spec.gitRange, opts)
+    : remoteRefs
+    ? BB.resolve(
+      remoteRefs.refs[spec.gitCommittish] || remoteRefs.refs[remoteRefs.shas[spec.gitCommittish]]
+    )
+    : null
+  })
+}
+
+function withTmp (opts, cb) {
+  if (opts.cache) {
+    // cacache has a special facility for working in a tmp dir
+    return cacache.tmp.withTmp(opts.cache, {tmpPrefix: 'git-clone'}, cb)
+  } else {
+    const tmpDir = path.join(osenv.tmpdir(), 'pacote-git-tmp')
+    const tmpName = uniqueFilename(tmpDir, 'git-clone')
+    const tmp = mkdirp(tmpName).then(() => tmpName).disposer(rimraf)
+    return BB.using(tmp, cb)
+  }
+}
+
+// Only certain whitelisted hosted gits support shadow cloning
+const SHALLOW_HOSTS = new Set(['github', 'gist', 'gitlab', 'bitbucket'])
+function cloneRepo (spec, repo, resolvedRef, rawRef, tmp, opts) {
+  const ref = resolvedRef ? resolvedRef.ref : rawRef
+  if (resolvedRef && spec.hosted && SHALLOW_HOSTS.has(spec.hosted.type)) {
+    return git.shallow(repo, ref, tmp, opts)
+  } else {
+    return git.clone(repo, ref, tmp, opts)
+  }
+}

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

@@ -0,0 +1,3 @@
+'use strict'
+
+module.exports = require('./git')

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

@@ -0,0 +1,3 @@
+'use strict'
+
+module.exports = require('./registry')

package/node-v8.11.1-linux-x64/lib/node_modules/npm/node_modules/pacote/lib/fetchers/registry/check-warning-header.js

@@ -0,0 +1,39 @@
+'use strict'
+
+const LRU = require('lru-cache')
+
+const WARNING_REGEXP = /^\s*(\d{3})\s+(\S+)\s+"(.*)"\s+"([^"]+)"/
+const BAD_HOSTS = new LRU({ max: 50 })
+
+module.exports = checkWarnings
+function checkWarnings (res, registry, opts) {
+  if (res.headers.has('warning') && !BAD_HOSTS.has(registry)) {
+    const warnings = {}
+    res.headers.raw()['warning'].forEach(w => {
+      const match = w.match(WARNING_REGEXP)
+      if (match) {
+        warnings[match[1]] = {
+          code: match[1],
+          host: match[2],
+          message: match[3],
+          date: new Date(match[4])
+        }
+      }
+    })
+    BAD_HOSTS.set(registry, true)
+    if (warnings['199']) {
+      if (warnings['199'].message.match(/ENOTFOUND/)) {
+        opts.log.warn('registry', `Using stale data from ${registry} because the host is inaccessible -- are you offline?`)
+      } else {
+        opts.log.warn('registry', `Unexpected warning for ${registry}: ${warnings['199'].message}`)
+      }
+    }
+    if (warnings['111']) {
+      // 111 Revalidation failed -- we're using stale data
+      opts.log.warn(
+        'registry',
+        `Using stale package data from ${registry} due to a request error during revalidation.`
+      )
+    }
+  }
+}

package/node-v8.11.1-linux-x64/lib/node_modules/npm/node_modules/pacote/lib/fetchers/registry/fetch.js

@@ -0,0 +1,109 @@
+'use strict'
+
+const BB = require('bluebird')
+const Buffer = require('safe-buffer').Buffer
+
+const checkWarnings = require('./check-warning-header')
+const fetch = require('make-fetch-happen')
+const registryKey = require('./registry-key')
+const url = require('url')
+
+module.exports = regFetch
+function regFetch (uri, registry, opts) {
+  const startTime = Date.now()
+  return fetch(uri, {
+    agent: opts.agent,
+    algorithms: opts.algorithms,
+    cache: getCacheMode(opts),
+    cacheManager: opts.cache,
+    ca: opts.ca,
+    cert: opts.cert,
+    headers: getHeaders(uri, registry, opts),
+    integrity: opts.integrity,
+    key: opts.key,
+    localAddress: opts.localAddress,
+    maxSockets: opts.maxSockets,
+    memoize: opts.memoize,
+    noProxy: opts.noProxy,
+    Promise: BB,
+    proxy: opts.proxy,
+    referer: opts.refer,
+    retry: opts.retry,
+    strictSSL: !!opts.strictSSL,
+    timeout: opts.timeout,
+    uid: opts.uid,
+    gid: opts.gid
+  }).then(res => {
+    if (res.headers.has('npm-notice') && !res.headers.has('x-local-cache')) {
+      opts.log.warn('notice', res.headers.get('npm-notice'))
+    }
+    checkWarnings(res, registry, opts)
+    if (res.status >= 400) {
+      const err = new Error(`${res.status} ${res.statusText}: ${
+        opts.spec ? opts.spec : uri
+      }`)
+      err.code = `E${res.status}`
+      err.uri = uri
+      err.response = res
+      err.spec = opts.spec
+      logRequest(uri, res, startTime, opts)
+      throw err
+    } else {
+      res.body.on('end', () => logRequest(uri, res, startTime, opts))
+      return res
+    }
+  })
+}
+
+function logRequest (uri, res, startTime, opts) {
+  const elapsedTime = Date.now() - startTime
+  const attempt = res.headers.get('x-fetch-attempts')
+  const attemptStr = attempt && attempt > 1 ? ` attempt #${attempt}` : ''
+  const cacheStr = res.headers.get('x-local-cache') ? ' (from cache)' : ''
+  opts.log.http(
+    'fetch',
+    `GET ${res.status} ${uri} ${elapsedTime}ms${attemptStr}${cacheStr}`
+  )
+}
+
+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
+}

package/node-v8.11.1-linux-x64/lib/node_modules/npm/node_modules/pacote/lib/fetchers/registry/index.js

@@ -0,0 +1,27 @@
+'use strict'
+
+const cacache = require('cacache')
+const Fetcher = require('../../fetch')
+const regManifest = require('./manifest')
+const regTarball = require('./tarball')
+
+const fetchRegistry = module.exports = Object.create(null)
+
+Fetcher.impl(fetchRegistry, {
+  manifest (spec, opts) {
+    return regManifest(spec, opts)
+  },
+
+  tarball (spec, opts) {
+    return regTarball(spec, opts)
+  },
+
+  fromManifest (manifest, spec, opts) {
+    return regTarball.fromManifest(manifest, spec, opts)
+  },
+
+  clearMemoized () {
+    cacache.clearMemoized()
+    regManifest.clearMemoized()
+  }
+})

package/node-v8.11.1-linux-x64/lib/node_modules/npm/node_modules/pacote/lib/fetchers/registry/manifest.js

@@ -0,0 +1,148 @@
+'use strict'
+
+const BB = require('bluebird')
+
+const fetch = require('./fetch')
+const LRU = require('lru-cache')
+const optCheck = require('../../util/opt-check')
+const pickManifest = require('npm-pick-manifest')
+const pickRegistry = require('./pick-registry')
+const ssri = require('ssri')
+const url = require('url')
+
+// Corgis are cute. 🐕🐶
+const CORGI_DOC = 'application/vnd.npm.install-v1+json; q=1.0, application/json; q=0.8, */*'
+const JSON_DOC = 'application/json'
+
+module.exports = manifest
+function manifest (spec, opts) {
+  opts = optCheck(opts)
+
+  const registry = pickRegistry(spec, opts)
+  const uri = metadataUrl(registry, spec.escapedName)
+
+  return getManifest(uri, registry, spec, opts).then(manifest => {
+    return annotateManifest(uri, registry, manifest)
+  })
+}
+
+function metadataUrl (registry, name) {
+  const normalized = registry.slice(-1) !== '/'
+  ? registry + '/'
+  : registry
+  return url.resolve(normalized, name)
+}
+
+function getManifest (uri, registry, spec, opts) {
+  return fetchPackument(uri, spec, registry, opts).then(packument => {
+    try {
+      return pickManifest(packument, spec.fetchSpec, {
+        defaultTag: opts.defaultTag,
+        includeDeprecated: opts.includeDeprecated
+      })
+    } catch (err) {
+      if (err.code === 'ETARGET' && packument._cached && !opts.offline) {
+        opts.log.silly(
+          'registry:manifest',
+          `no matching version for ${spec.name}@${spec.fetchSpec} in the cache. Forcing revalidation`
+        )
+        opts.preferOffline = false
+        opts.preferOnline = true
+        return fetchPackument(uri, spec, registry, opts).then(packument => {
+          return pickManifest(packument, spec.fetchSpec, {
+            defaultTag: opts.defaultTag
+          })
+        })
+      } else {
+        throw err
+      }
+    }
+  })
+}
+
+// TODO - make this an opt
+const MEMO = new LRU({
+  length: m => m._contentLength,
+  max: 200 * 1024 * 1024, // 200MB
+  maxAge: 30 * 1000 // 30s
+})
+
+module.exports.clearMemoized = clearMemoized
+function clearMemoized () {
+  MEMO.reset()
+}
+
+function fetchPackument (uri, spec, registry, opts) {
+  const mem = pickMem(opts)
+  if (mem && !opts.preferOnline && mem.has(uri)) {
+    return BB.resolve(mem.get(uri))
+  }
+
+  return fetch(uri, registry, Object.assign({
+    headers: {
+      'pacote-req-type': 'packument',
+      'pacote-pkg-id': `registry:${manifest.name}`,
+      accept: opts.fullMetadata ? JSON_DOC : CORGI_DOC
+    },
+    spec
+  }, opts, {
+    // Force integrity to null: we never check integrity hashes for manifests
+    integrity: null
+  })).then(res => res.json().then(packument => {
+    packument._cached = decodeURIComponent(res.headers.has('x-local-cache'))
+    packument._contentLength = +res.headers.get('content-length')
+    // NOTE - we need to call pickMem again because proxy
+    //        objects get reused!
+    const mem = pickMem(opts)
+    if (mem) {
+      mem.set(uri, packument)
+    }
+    return packument
+  }))
+}
+
+class ObjProxy {
+  get (key) { return this.obj[key] }
+  set (key, val) { this.obj[key] = val }
+}
+
+// This object is used synchronously and immediately, so
+// we can safely reuse it instead of consing up new ones
+const PROX = new ObjProxy()
+function pickMem (opts) {
+  if (!opts || !opts.memoize) {
+    return MEMO
+  } else if (opts.memoize.get && opts.memoize.set) {
+    return opts.memoize
+  } else if (typeof opts.memoize === 'object') {
+    PROX.obj = opts.memoize
+    return PROX
+  } else {
+    return null
+  }
+}
+
+function annotateManifest (uri, registry, manifest) {
+  const shasum = manifest.dist && manifest.dist.shasum
+  manifest._integrity = manifest.dist && manifest.dist.integrity
+  manifest._shasum = shasum
+  if (!manifest._integrity && shasum) {
+    // Use legacy dist.shasum field if available.
+    manifest._integrity = ssri.fromHex(shasum, 'sha1').toString()
+  }
+  manifest._resolved = (
+    manifest.dist && manifest.dist.tarball
+  )
+  if (!manifest._resolved) {
+    const err = new Error(
+      `Manifest for ${manifest.name}@${manifest.version} from ${uri} is missing a tarball url (pkg.dist.tarball). Guessing a default.`
+    )
+    err.code = 'ENOTARBALL'
+    err.manifest = manifest
+    if (!manifest._warnings) { manifest._warnings = [] }
+    manifest._warnings.push(err.message)
+    manifest._resolved =
+    `${registry}/${manifest.name}/-/${manifest.name}-${manifest.version}.tgz`
+  }
+  return manifest
+}

package/node-v8.11.1-linux-x64/lib/node_modules/npm/node_modules/pacote/lib/fetchers/registry/pick-registry.js

@@ -0,0 +1,17 @@
+'use strict'
+
+module.exports = pickRegistry
+function pickRegistry (spec, opts) {
+  let registry = spec.scope && opts.scopeTargets[spec.scope]
+
+  if (!registry && opts.scope) {
+    const prefix = opts.scope[0] === '@' ? '' : '@'
+    registry = opts.scopeTargets[prefix + opts.scope]
+  }
+
+  if (!registry) {
+    registry = opts.registry
+  }
+
+  return registry
+}

package/node-v8.11.1-linux-x64/lib/node_modules/npm/node_modules/pacote/lib/fetchers/registry/registry-key.js

@@ -0,0 +1,16 @@
+'use strict'
+
+const url = require('url')
+
+// Called a nerf dart in the main codebase. Used as a "safe"
+// key when fetching registry info from config.
+module.exports = registryKey
+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/node_modules/pacote/lib/fetchers/registry/tarball.js

@@ -0,0 +1,85 @@
+'use strict'
+
+const BB = require('bluebird')
+
+const fetch = require('./fetch')
+const manifest = require('./manifest')
+const optCheck = require('../../util/opt-check')
+const PassThrough = require('stream').PassThrough
+const pickRegistry = require('./pick-registry')
+const pipe = BB.promisify(require('mississippi').pipe)
+const ssri = require('ssri')
+const url = require('url')
+
+module.exports = tarball
+function tarball (spec, opts) {
+  opts = optCheck(opts)
+  const stream = new PassThrough()
+  manifest(spec, opts).then(manifest => {
+    stream.emit('manifest', manifest)
+    return pipe(
+      fromManifest(manifest, spec, opts).on(
+        'integrity', i => stream.emit('integrity', i)
+      ),
+      stream
+    )
+  }).catch(err => stream.emit('error', err))
+  return stream
+}
+
+module.exports.fromManifest = fromManifest
+function fromManifest (manifest, spec, opts) {
+  opts = optCheck(opts)
+  opts.scope = spec.scope || opts.scope
+  const stream = new PassThrough()
+  const registry = pickRegistry(spec, opts)
+  const uri = getTarballUrl(registry, manifest)
+  fetch(uri, registry, Object.assign({
+    headers: {
+      'pacote-req-type': 'tarball',
+      'pacote-pkg-id': `registry:${
+        spec.type === 'remote'
+        ? spec
+        : `${manifest.name}@${manifest.version}`
+      }`
+    },
+    integrity: manifest._integrity,
+    algorithms: [
+      manifest._integrity
+      ? ssri.parse(manifest._integrity).pickAlgorithm()
+      : 'sha1'
+    ],
+    spec
+  }, opts)).then(res => {
+    const hash = res.headers.get('x-local-cache-hash')
+    if (hash) {
+      stream.emit('integrity', decodeURIComponent(hash))
+    }
+    res.body.on('error', err => stream.emit('error', err))
+    res.body.pipe(stream)
+  }).catch(err => stream.emit('error', err))
+  return stream
+}
+
+function getTarballUrl (registry, manifest) {
+  // https://github.com/npm/npm/pull/9471
+  //
+  // TL;DR: Some alternative registries host tarballs on http and packuments on
+  // https, and vice-versa. There's also a case where people who can't use SSL
+  // to access the npm registry, for example, might use
+  // `--registry=http://registry.npmjs.org/`. In this case, we need to rewrite
+  // `tarball` to match the protocol.
+  //
+  const reg = url.parse(registry)
+  const tarball = url.parse(manifest._resolved)
+  if (reg.hostname === tarball.hostname && reg.protocol !== tarball.protocol) {
+    tarball.protocol = reg.protocol
+    // Ports might be same host different protocol!
+    if (reg.port !== tarball.port) {
+      delete tarball.host
+      tarball.port = reg.port
+    }
+    delete tarball.href
+  }
+  return url.format(tarball)
+}

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

@@ -0,0 +1,30 @@
+'use strict'
+
+const BB = require('bluebird')
+
+const Fetcher = require('../fetch')
+const fetchRegistry = require('./registry')
+
+const fetchRemote = module.exports = Object.create(null)
+
+Fetcher.impl(fetchRemote, {
+  manifest (spec, opts) {
+    // We can't get the manifest for a remote tarball until
+    // we extract the tarball itself.
+    // `finalize-manifest` takes care of this process of extracting
+    // a manifest based on ./tarball.js
+    return BB.resolve(null)
+  },
+
+  tarball (spec, opts) {
+    const uri = spec._resolved || spec.fetchSpec
+    return fetchRegistry.fromManifest({
+      _resolved: uri,
+      _integrity: opts.integrity
+    }, spec, opts)
+  },
+
+  fromManifest (manifest, spec, opts) {
+    return this.tarball(manifest || spec, opts)
+  }
+})

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

@@ -0,0 +1,3 @@
+'use strict'
+
+module.exports = require('./registry')

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

@@ -0,0 +1,3 @@
+'use strict'
+
+module.exports = require('./registry')