jfrog-cli-v2-jf 2.6.0

package/node-v8.11.1-linux-x64/lib/node_modules/npm/node_modules/npm-registry-client/lib/org.js

@@ -0,0 +1,62 @@
+'use strict'
+
+module.exports = org
+
+var assert = require('assert')
+var url = require('url')
+
+var subcommands = {}
+
+function org (subcommand, uri, params, cb) {
+  orgAssertions(subcommand, uri, params, cb)
+  return subcommands[subcommand].call(this, uri, params, cb)
+}
+
+subcommands.set = subcommands.add = function (uri, params, cb) {
+  return this.request(apiUri(uri, 'org', params.org, 'user'), {
+    method: 'PUT',
+    auth: params.auth,
+    body: JSON.stringify({
+      user: params.user,
+      role: params.role
+    })
+  }, cb)
+}
+
+subcommands.rm = function (uri, params, cb) {
+  return this.request(apiUri(uri, 'org', params.org, 'user'), {
+    method: 'DELETE',
+    auth: params.auth,
+    body: JSON.stringify({
+      user: params.user
+    })
+  }, cb)
+}
+
+subcommands.ls = function (uri, params, cb) {
+  return this.request(apiUri(uri, 'org', params.org, 'user'), {
+    method: 'GET',
+    auth: params.auth
+  }, cb)
+}
+
+function apiUri (registryUri) {
+  var path = Array.prototype.slice.call(arguments, 1)
+    .map(encodeURIComponent)
+    .join('/')
+  return url.resolve(registryUri, '-/' + path)
+}
+
+function orgAssertions (subcommand, uri, params, cb) {
+  assert(subcommand, 'subcommand is required')
+  assert(subcommands.hasOwnProperty(subcommand),
+         'org subcommand must be one of ' + Object.keys(subcommands))
+  assert(typeof uri === 'string', 'registry URI is required')
+  assert(typeof params === 'object', 'params are required')
+  assert(typeof params.auth === 'object', 'auth is required')
+  assert(!cb || typeof cb === 'function', 'callback must be a function')
+  assert(typeof params.org === 'string', 'org name is required')
+  if (subcommand === 'rm' || subcommand === 'add' || subcommand === 'set') {
+    assert(typeof params.user === 'string', 'user is required')
+  }
+}

package/node-v8.11.1-linux-x64/lib/node_modules/npm/node_modules/npm-registry-client/lib/ping.js

@@ -0,0 +1,21 @@
+module.exports = ping
+
+var url = require('url')
+var assert = require('assert')
+
+function ping (uri, params, cb) {
+  assert(typeof uri === 'string', 'must pass registry URI to ping')
+  assert(params && typeof params === 'object', 'must pass params to ping')
+  assert(typeof cb === 'function', 'must pass callback to ping')
+
+  var auth = params.auth
+  assert(auth && typeof auth === 'object', 'must pass auth to ping')
+
+  this.request(url.resolve(uri, '-/ping?write=true'), { auth: auth }, function (er, fullData, data, response) {
+    if (er || fullData) {
+      cb(er, fullData, data, response)
+    } else {
+      cb(new Error('No data received'))
+    }
+  })
+}

package/node-v8.11.1-linux-x64/lib/node_modules/npm/node_modules/npm-registry-client/lib/publish.js

@@ -0,0 +1,194 @@
+module.exports = publish
+
+var url = require('url')
+var semver = require('semver')
+var Stream = require('stream').Stream
+var assert = require('assert')
+var fixer = require('normalize-package-data').fixer
+var concat = require('concat-stream')
+var ssri = require('ssri')
+
+function escaped (name) {
+  return name.replace('/', '%2f')
+}
+
+function publish (uri, params, cb) {
+  assert(typeof uri === 'string', 'must pass registry URI to publish')
+  assert(params && typeof params === 'object', 'must pass params to publish')
+  assert(typeof cb === 'function', 'must pass callback to publish')
+
+  var access = params.access
+  assert(
+    (!access) || ['public', 'restricted'].indexOf(access) !== -1,
+    "if present, access level must be either 'public' or 'restricted'"
+  )
+
+  var auth = params.auth
+  assert(auth && typeof auth === 'object', 'must pass auth to publish')
+  if (!(auth.token ||
+        (auth.password && auth.username && auth.email))) {
+    var er = new Error('auth required for publishing')
+    er.code = 'ENEEDAUTH'
+    return cb(er)
+  }
+
+  var metadata = params.metadata
+  assert(
+    metadata && typeof metadata === 'object',
+    'must pass package metadata to publish'
+  )
+  try {
+    fixer.fixNameField(metadata, {strict: true, allowLegacyCase: true})
+  } catch (er) {
+    return cb(er)
+  }
+  var version = semver.clean(metadata.version)
+  if (!version) return cb(new Error('invalid semver: ' + metadata.version))
+  metadata.version = version
+
+  var body = params.body
+  assert(body, 'must pass package body to publish')
+  assert(body instanceof Stream, 'package body passed to publish must be a stream')
+  var client = this
+  var sink = concat(function (tarbuffer) {
+    putFirst.call(client, uri, metadata, tarbuffer, access, auth, cb)
+  })
+  sink.on('error', cb)
+  body.pipe(sink)
+}
+
+function putFirst (registry, data, tarbuffer, access, auth, cb) {
+  // optimistically try to PUT all in one single atomic thing.
+  // If 409, then GET and merge, try again.
+  // If other error, then fail.
+
+  var root = {
+    _id: data.name,
+    name: data.name,
+    description: data.description,
+    'dist-tags': {},
+    versions: {},
+    readme: data.readme || ''
+  }
+
+  if (access) root.access = access
+
+  if (!auth.token) {
+    root.maintainers = [{ name: auth.username, email: auth.email }]
+    data.maintainers = JSON.parse(JSON.stringify(root.maintainers))
+  }
+
+  root.versions[ data.version ] = data
+  var tag = data.tag || this.config.defaultTag
+  root['dist-tags'][tag] = data.version
+
+  var tbName = data.name + '-' + data.version + '.tgz'
+  var tbURI = data.name + '/-/' + tbName
+  var integrity = ssri.fromData(tarbuffer, {
+    algorithms: ['sha1', 'sha512']
+  })
+
+  data._id = data.name + '@' + data.version
+  data.dist = data.dist || {}
+  // Don't bother having sha1 in the actual integrity field
+  data.dist.integrity = integrity['sha512'][0].toString()
+  // Legacy shasum support
+  data.dist.shasum = integrity['sha1'][0].hexDigest()
+  data.dist.tarball = url.resolve(registry, tbURI)
+                         .replace(/^https:\/\//, 'http://')
+
+  root._attachments = {}
+  root._attachments[ tbName ] = {
+    'content_type': 'application/octet-stream',
+    'data': tarbuffer.toString('base64'),
+    'length': tarbuffer.length
+  }
+
+  var fixed = url.resolve(registry, escaped(data.name))
+  var client = this
+  var options = {
+    method: 'PUT',
+    body: root,
+    auth: auth
+  }
+  this.request(fixed, options, function (er, parsed, json, res) {
+    var r409 = 'must supply latest _rev to update existing package'
+    var r409b = 'Document update conflict.'
+    var conflict = res && res.statusCode === 409
+    if (parsed && (parsed.reason === r409 || parsed.reason === r409b)) {
+      conflict = true
+    }
+
+    // a 409 is typical here.  GET the data and merge in.
+    if (er && !conflict) {
+      client.log.error('publish', 'Failed PUT ' + (res && res.statusCode))
+      return cb(er)
+    }
+
+    if (!er && !conflict) return cb(er, parsed, json, res)
+
+    // let's see what versions are already published.
+    client.request(fixed + '?write=true', { auth: auth }, function (er, current) {
+      if (er) return cb(er)
+
+      putNext.call(client, registry, data.version, root, current, auth, cb)
+    })
+  })
+}
+
+function putNext (registry, newVersion, root, current, auth, cb) {
+  // already have the tardata on the root object
+  // just merge in existing stuff
+  var curVers = Object.keys(current.versions || {}).map(function (v) {
+    return semver.clean(v, true)
+  }).concat(Object.keys(current.time || {}).map(function (v) {
+    if (semver.valid(v, true)) return semver.clean(v, true)
+  }).filter(function (v) {
+    return v
+  }))
+
+  if (curVers.indexOf(newVersion) !== -1) {
+    return cb(conflictError(root.name, newVersion))
+  }
+
+  current.versions[newVersion] = root.versions[newVersion]
+  current._attachments = current._attachments || {}
+  for (var i in root) {
+    switch (i) {
+      // objects that copy over the new stuffs
+      case 'dist-tags':
+      case 'versions':
+      case '_attachments':
+        for (var j in root[i]) {
+          current[i][j] = root[i][j]
+        }
+        break
+
+      // ignore these
+      case 'maintainers':
+        break
+
+      // copy
+      default:
+        current[i] = root[i]
+    }
+  }
+  var maint = JSON.parse(JSON.stringify(root.maintainers))
+  root.versions[newVersion].maintainers = maint
+
+  var uri = url.resolve(registry, escaped(root.name))
+  var options = {
+    method: 'PUT',
+    body: current,
+    auth: auth
+  }
+  this.request(uri, options, cb)
+}
+
+function conflictError (pkgid, version) {
+  var e = new Error('cannot modify pre-existing version')
+  e.code = 'EPUBLISHCONFLICT'
+  e.pkgid = pkgid
+  e.version = version
+  return e
+}

package/node-v8.11.1-linux-x64/lib/node_modules/npm/node_modules/npm-registry-client/lib/request.js

@@ -0,0 +1,321 @@
+module.exports = regRequest
+
+// npm: means
+// 1. https
+// 2. send authorization
+// 3. content-type is 'application/json' -- metadata
+//
+var assert = require('assert')
+var url = require('url')
+var zlib = require('zlib')
+var Stream = require('stream').Stream
+var STATUS_CODES = require('http').STATUS_CODES
+
+var request = require('request')
+var once = require('once')
+
+function regRequest (uri, params, cb_) {
+  assert(typeof uri === 'string', 'must pass uri to request')
+  assert(params && typeof params === 'object', 'must pass params to request')
+  assert(typeof cb_ === 'function', 'must pass callback to request')
+
+  params.method = params.method || 'GET'
+  this.log.verbose('request', 'uri', uri)
+
+  // Since there are multiple places where an error could occur,
+  // don't let the cb be called more than once.
+  var cb = once(cb_)
+
+  if (uri.match(/^\/?favicon.ico/)) {
+    return cb(new Error("favicon.ico isn't a package, it's a picture."))
+  }
+
+  var adduserChange = /\/?-\/user\/org\.couchdb\.user:([^/]+)\/-rev/
+  var isUserChange = uri.match(adduserChange)
+  var adduserNew = /\/?-\/user\/org\.couchdb\.user:([^/?]+)$/
+  var isNewUser = uri.match(adduserNew)
+  var alwaysAuth = params.auth && params.auth.alwaysAuth
+  var isDelete = params.method === 'DELETE'
+  var isWrite = params.body || isDelete
+
+  if (isUserChange && !isWrite) {
+    return cb(new Error('trying to change user document without writing(?!)'))
+  }
+
+  if (params.authed == null) {
+    // new users can *not* use auth, because they don't *have* auth yet
+    if (isUserChange) {
+      this.log.verbose('request', 'updating existing user; sending authorization')
+      params.authed = true
+    } else if (isNewUser) {
+      this.log.verbose('request', "new user, so can't send auth")
+      params.authed = false
+    } else if (alwaysAuth) {
+      this.log.verbose('request', 'always-auth set; sending authorization')
+      params.authed = true
+    } else if (isWrite) {
+      this.log.verbose('request', 'sending authorization for write operation')
+      params.authed = true
+    } else {
+      // most of the time we don't want to auth
+      this.log.verbose('request', 'no auth needed')
+      params.authed = false
+    }
+  }
+
+  var self = this
+  this.attempt(function (operation) {
+    makeRequest.call(self, uri, params, function (er, parsed, raw, response) {
+      if (response) {
+        self.log.verbose('headers', response.headers)
+        if (response.headers['npm-notice']) {
+          self.log.warn('notice', response.headers['npm-notice'])
+        }
+      }
+
+      if (!er || (er.message && er.message.match(/^SSL Error/))) {
+        if (er) er.code = 'ESSL'
+        return cb(er, parsed, raw, response)
+      }
+
+      // Only retry on 408, 5xx or no `response`.
+      var statusCode = response && response.statusCode
+
+      var timeout = statusCode === 408
+      var serverError = statusCode >= 500
+      var statusRetry = !statusCode || timeout || serverError
+      if (er && statusRetry && operation.retry(er)) {
+        self.log.info('retry', 'will retry, error on last attempt: ' + er)
+        return undefined
+      }
+      cb.apply(null, arguments)
+    })
+  })
+}
+
+function makeRequest (uri, params, cb_) {
+  var socket
+  var cb = once(function (er, parsed, raw, response) {
+    if (socket) {
+      // The socket might be returned to a pool for re-use, so don’t keep
+      // the 'error' listener from here attached.
+      socket.removeListener('error', cb)
+    }
+
+    return cb_(er, parsed, raw, response)
+  })
+
+  var parsed = url.parse(uri)
+  var headers = {}
+
+  // metadata should be compressed
+  headers['accept-encoding'] = 'gzip'
+
+  // metadata should be minified, if the registry supports it
+
+  var er = this.authify(params.authed, parsed, headers, params.auth)
+  if (er) return cb_(er)
+
+  var useCorgi = params.fullMetadata == null ? false : !params.fullMetadata
+
+  var opts = this.initialize(
+    parsed,
+    params.method,
+    useCorgi ? 'application/vnd.npm.install-v1+json; q=1.0, application/json; q=0.8, */*' : 'application/json',
+    headers
+  )
+
+  opts.followRedirect = (typeof params.follow === 'boolean' ? params.follow : true)
+  opts.encoding = null // tell request let body be Buffer instance
+
+  if (params.etag) {
+    this.log.verbose('etag', params.etag)
+    headers[params.method === 'GET' ? 'if-none-match' : 'if-match'] = params.etag
+  }
+
+  if (params.lastModified && params.method === 'GET') {
+    this.log.verbose('lastModified', params.lastModified)
+    headers['if-modified-since'] = params.lastModified
+  }
+
+  // figure out wth body is
+  if (params.body) {
+    if (Buffer.isBuffer(params.body)) {
+      opts.body = params.body
+      headers['content-type'] = 'application/json'
+      headers['content-length'] = params.body.length
+    } else if (typeof params.body === 'string') {
+      opts.body = params.body
+      headers['content-type'] = 'application/json'
+      headers['content-length'] = Buffer.byteLength(params.body)
+    } else if (params.body instanceof Stream) {
+      headers['content-type'] = 'application/octet-stream'
+      if (params.body.size) headers['content-length'] = params.body.size
+    } else {
+      delete params.body._etag
+      delete params.body._lastModified
+      opts.json = params.body
+    }
+  }
+
+  this.log.http('request', params.method, parsed.href || '/')
+
+  var done = requestDone.call(this, params.method, uri, cb)
+  var req = request(opts, params.streaming ? undefined : decodeResponseBody(done))
+
+  req.on('error', cb)
+
+  // This should not be necessary, as the HTTP implementation in Node
+  // passes errors occurring on the socket to the request itself. Being overly
+  // cautious comes at a low cost, though.
+  req.on('socket', function (s) {
+    socket = s
+    socket.on('error', cb)
+  })
+
+  if (params.streaming) {
+    req.on('response', function (response) {
+      if (response.statusCode >= 400) {
+        var parts = []
+        response.on('data', function (data) {
+          parts.push(data)
+        })
+        response.on('end', function () {
+          decodeResponseBody(done)(null, response, Buffer.concat(parts))
+        })
+      } else {
+        response.on('end', function () {
+          // don't ever re-use connections that had server errors.
+          // those sockets connect to the Bad Place!
+          if (response.socket && response.statusCode > 500) {
+            response.socket.destroy()
+          }
+        })
+
+        return cb(null, response)
+      }
+    })
+  }
+
+  if (params.body && (params.body instanceof Stream)) {
+    params.body.pipe(req)
+  }
+}
+
+function decodeResponseBody (cb) {
+  return function (er, response, data) {
+    if (er) return cb(er, response, data)
+
+    // don't ever re-use connections that had server errors.
+    // those sockets connect to the Bad Place!
+    if (response.socket && response.statusCode > 500) {
+      response.socket.destroy()
+    }
+
+    if (response.headers['content-encoding'] !== 'gzip') {
+      return cb(er, response, data)
+    }
+
+    zlib.gunzip(data, function (er, buf) {
+      if (er) return cb(er, response, data)
+
+      cb(null, response, buf)
+    })
+  }
+}
+
+// cb(er, parsed, raw, response)
+function requestDone (method, where, cb) {
+  return function (er, response, data) {
+    if (er) return cb(er)
+
+    var urlObj = url.parse(where)
+    if (urlObj.auth) urlObj.auth = '***'
+    this.log.http(response.statusCode, url.format(urlObj))
+
+    if (Buffer.isBuffer(data)) {
+      data = data.toString()
+    }
+
+    var parsed
+    if (data && typeof data === 'string' && response.statusCode !== 304) {
+      try {
+        parsed = JSON.parse(data)
+      } catch (ex) {
+        ex.message += '\n' + data
+        this.log.verbose('bad json', data)
+        this.log.error('registry', 'error parsing json')
+        return cb(ex, null, data, response)
+      }
+    } else if (data) {
+      parsed = data
+      data = JSON.stringify(parsed)
+    }
+
+    // expect data with any error codes
+    if (!data && response.statusCode >= 400) {
+      var code = response.statusCode
+      return cb(
+        makeError(code + ' ' + STATUS_CODES[code], null, code),
+        null,
+        data,
+        response
+      )
+    }
+
+    er = null
+    if (parsed && response.headers.etag) {
+      parsed._etag = response.headers.etag
+    }
+
+    if (parsed && response.headers['last-modified']) {
+      parsed._lastModified = response.headers['last-modified']
+    }
+
+    // for the search endpoint, the 'error' property can be an object
+    if ((parsed && parsed.error && typeof parsed.error !== 'object') ||
+        response.statusCode >= 400) {
+      var w = url.parse(where).pathname.substr(1)
+      var name
+      if (!w.match(/^-/)) {
+        w = w.split('/')
+        var index = w.indexOf('_rewrite')
+        if (index === -1) {
+          index = w.length - 1
+        } else {
+          index++
+        }
+        name = decodeURIComponent(w[index])
+      }
+
+      if (!parsed.error) {
+        er = makeError(
+          'Registry returned ' + response.statusCode +
+          ' for ' + method +
+          ' on ' + where,
+          name,
+          response.statusCode
+        )
+      } else if (name && parsed.error === 'not_found') {
+        er = makeError('404 Not Found: ' + name, name, response.statusCode)
+      } else {
+        er = makeError(
+          parsed.error + ' ' + (parsed.reason || '') + ': ' + (name || w),
+          name,
+          response.statusCode
+        )
+      }
+    }
+    return cb(er, parsed, data, response)
+  }.bind(this)
+}
+
+function makeError (message, name, code) {
+  var er = new Error(message)
+  if (name) er.pkgid = name
+  if (code) {
+    er.statusCode = code
+    er.code = 'E' + code
+  }
+  return er
+}

package/node-v8.11.1-linux-x64/lib/node_modules/npm/node_modules/npm-registry-client/lib/send-anonymous-CLI-metrics.js

@@ -0,0 +1,19 @@
+module.exports = send
+
+var assert = require('assert')
+var url = require('url')
+
+function send (registryUrl, params, cb) {
+  assert(typeof registryUrl === 'string', 'must pass registry URI')
+  assert(params && typeof params === 'object', 'must pass params')
+  assert(typeof cb === 'function', 'must pass callback')
+
+  var uri = url.resolve(registryUrl, '-/npm/anon-metrics/v1/' +
+    encodeURIComponent(params.metricId))
+
+  this.request(uri, {
+    method: 'PUT',
+    body: JSON.stringify(params.metrics),
+    authed: false
+  }, cb)
+}

package/node-v8.11.1-linux-x64/lib/node_modules/npm/node_modules/npm-registry-client/lib/star.js

@@ -0,0 +1,51 @@
+module.exports = star
+
+var assert = require('assert')
+
+function star (uri, params, cb) {
+  assert(typeof uri === 'string', 'must pass registry URI to star')
+  assert(params && typeof params === 'object', 'must pass params to star')
+  assert(typeof cb === 'function', 'must pass callback to star')
+
+  var starred = !!params.starred
+
+  var auth = params.auth
+  assert(auth && typeof auth === 'object', 'must pass auth to star')
+  if (!(auth.token || (auth.password && auth.username && auth.email))) {
+    var er = new Error('Must be logged in to star/unstar packages')
+    er.code = 'ENEEDAUTH'
+    return cb(er)
+  }
+
+  var client = this
+  this.request(uri + '?write=true', { auth: auth }, function (er, fullData) {
+    if (er) return cb(er)
+
+    client.whoami(uri, params, function (er, username) {
+      if (er) return cb(er)
+
+      var data = {
+        _id: fullData._id,
+        _rev: fullData._rev,
+        users: fullData.users || {}
+      }
+
+      if (starred) {
+        client.log.info('starring', data._id)
+        data.users[username] = true
+        client.log.verbose('starring', data)
+      } else {
+        delete data.users[username]
+        client.log.info('unstarring', data._id)
+        client.log.verbose('unstarring', data)
+      }
+
+      var options = {
+        method: 'PUT',
+        body: data,
+        auth: auth
+      }
+      return client.request(uri, options, cb)
+    })
+  })
+}

package/node-v8.11.1-linux-x64/lib/node_modules/npm/node_modules/npm-registry-client/lib/stars.js

@@ -0,0 +1,18 @@
+module.exports = stars
+
+var assert = require('assert')
+var url = require('url')
+
+function stars (uri, params, cb) {
+  assert(typeof uri === 'string', 'must pass registry URI to stars')
+  assert(params && typeof params === 'object', 'must pass params to stars')
+  assert(typeof cb === 'function', 'must pass callback to stars')
+
+  var auth = params.auth
+  var name = params.username || (auth && auth.username)
+  if (!name) return cb(new Error('must pass either username or auth to stars'))
+  var encoded = encodeURIComponent(name)
+  var path = '-/_view/starredByUser?key="' + encoded + '"'
+
+  this.request(url.resolve(uri, path), { auth: auth }, cb)
+}