@heroku/heroku-cli-util 8.0.12

package/lib/command.js

@@ -0,0 +1,171 @@
+'use strict'
+
+const Heroku = require('heroku-client')
+const cli = require('..')
+const auth = require('./auth')
+const vars = require('./vars')
+const Mutex = require('./mutex')
+
+function twoFactorWrapper (options, preauths, context) {
+  return function (res, buffer) {
+    let body
+    try {
+      body = this.parseBody(buffer)
+    } catch (e) {
+      this._handleFailure(res, buffer)
+    }
+
+    // safety check for if we have already seen this request for preauthing
+    // this prevents an infinite loop in case some preauth fails silently
+    // and we continue to get two_factor failures
+
+    // this might be better done with a timer in case a command takes too long
+    // and the preauthorization runs out, but that seemed unlikely
+    if (res.statusCode === 403 && body.id === 'two_factor' && !preauths.requests.includes(this)) {
+      let self = this
+      // default preauth to always happen unless explicitly disabled
+      if (options.preauth === false || !body.app) {
+        twoFactorPrompt(options, preauths, context)
+          .then(function (secondFactor) {
+            self.options.headers = Object.assign({}, self.options.headers, { 'Heroku-Two-Factor-Code': secondFactor })
+            self.request()
+          })
+          .catch(function (err) {
+            self.reject(err)
+          })
+      } else {
+        preauths.requests.push(self)
+
+        // if multiple requests are run in parallel for the same app, we should
+        // only preauth for the first so save the fact we already preauthed
+        if (!preauths.promises[body.app.name]) {
+          preauths.promises[body.app.name] = twoFactorPrompt(options, preauths, context)
+            .then(function (secondFactor) {
+              return cli.preauth(body.app.name, heroku(context), secondFactor)
+            })
+        }
+
+        preauths.promises[body.app.name].then(function () {
+          self.request()
+        })
+          .catch(function (err) {
+            self.reject(err)
+          })
+      }
+    } else {
+      this._handleFailure(res, buffer)
+    }
+  }
+}
+
+function apiMiddleware (options, preauths, context) {
+  let twoFactor = twoFactorWrapper(options, preauths, context)
+  return function (response, cb) {
+    let warning = response.headers['x-heroku-warning'] || response.headers['warning-message']
+    if (warning) cli.action.warn(warning)
+
+    // override the _handleFailure for this request
+    if (!this._handleFailure) {
+      this._handleFailure = this.handleFailure
+      this.handleFailure = twoFactor.bind(this)
+    }
+
+    cb()
+  }
+}
+
+function heroku (context, options) {
+  let host = context.apiUrl || vars.apiUrl || 'https://api.heroku.com'
+
+  let preauths = {
+    promises: {},
+    requests: [],
+    twoFactorMutex: new Mutex()
+  }
+
+  let opts = {
+    userAgent: context.version,
+    debug: context.debug,
+    debugHeaders: context.debugHeaders,
+    token: context.auth ? context.auth.password : null,
+    host: host,
+    headers: {},
+    rejectUnauthorized: !(process.env.HEROKU_SSL_VERIFY === 'disable' || host.endsWith('herokudev.com')),
+    middleware: apiMiddleware(options, preauths, context)
+  }
+  if (process.env.HEROKU_HEADERS) {
+    Object.assign(opts.headers, JSON.parse(process.env.HEROKU_HEADERS))
+  }
+  if (context.secondFactor) {
+    Object.assign(opts.headers, { 'Heroku-Two-Factor-Code': context.secondFactor })
+  }
+  if (context.reason) {
+    Object.assign(opts.headers, { 'X-Heroku-Sudo-Reason': context.reason })
+  }
+  cli.heroku = new Heroku(opts)
+  return cli.heroku
+}
+
+let httpsProxy = process.env.HTTPS_PROXY || process.env.https_proxy || process.env.HTTP_PROXY || process.env.http_proxy
+
+function setupHttpProxy () {
+  const url = require('url')
+  cli.hush(`proxy set to ${httpsProxy}`)
+  let proxy = url.parse(httpsProxy)
+  process.env.HEROKU_HTTP_PROXY_HOST = proxy.hostname
+  process.env.HEROKU_HTTP_PROXY_PORT = proxy.port
+  process.env.HEROKU_HTTP_PROXY_AUTH = proxy.auth
+}
+
+function relogin () {
+  if (process.env.HEROKU_LOGIN_REDIRECT === '1') return auth.login({ save: true })
+  process.env.HEROKU_LOGIN_REDIRECT = '1'
+  require('child_process').execSync('heroku login', { stdio: 'inherit' })
+  return Promise.resolve()
+}
+
+function twoFactorPrompt (options, preauths, context) {
+  cli.yubikey.enable()
+  return preauths.twoFactorMutex.synchronize(function () {
+    return cli.prompt('Two-factor code', { mask: true })
+      .catch(function (err) {
+        cli.yubikey.disable()
+        throw err
+      })
+      .then(function (secondFactor) {
+        cli.yubikey.disable()
+        return secondFactor
+      })
+  })
+}
+
+function reasonPrompt (context) {
+  return cli.prompt('Reason')
+    .then(function (reason) {
+      context.reason = reason
+    })
+}
+
+module.exports = function command (options, fn) {
+  return function (context) {
+    if (typeof options === 'function') [fn, options] = [options, {}]
+    if (httpsProxy) setupHttpProxy()
+    cli.color.enabled = context.supportsColor
+    let handleErr = cli.errorHandler({ debug: context.debug })
+    let run = function () {
+      context.auth = { password: auth.token() }
+      let p = fn(context, heroku(context, options))
+      if (!p.catch) return
+      return p.catch(function (err) {
+        if (err && err.body && err.body.id === 'unauthorized') {
+          cli.error(err.body.message || 'Unauthorized')
+          return relogin().then(run).catch(handleErr)
+        } else if (err && err.body && err.body.id === 'sudo_reason_required') {
+          cli.warn(err.body.message)
+          return reasonPrompt(context).then(run).catch(handleErr)
+        } else throw err
+      }).catch(handleErr)
+    }
+    return run()
+  }
+}

package/lib/console.js

@@ -0,0 +1,105 @@
+'use strict'
+
+var cli = require('..')
+const stripAnsi = require('strip-ansi')
+
+var mocking
+
+function concatArguments (args) {
+  return Array.prototype.map.call(args, function (arg) {
+    return arg + ''
+  }).join(' ')
+}
+
+/**
+ * log is a wrapper for console.log() but can be mocked
+ *
+ * @param {...Object} obj - objects to be printed to stdout
+ */
+function log () {
+  if (mocking) {
+    cli.stdout += stripAnsi(concatArguments(arguments) + '\n')
+  } else {
+    console.log.apply(null, arguments)
+  }
+}
+
+/**
+ * writeLog is a wrapper for process.stdout.write() but can be mocked
+ *
+ * @param {...Object} obj - objects to be printed to stdout
+ */
+function writeLog () {
+  if (mocking) {
+    cli.stdout += stripAnsi(concatArguments(arguments))
+  } else {
+    process.stdout.write.apply(process.stdout, arguments)
+  }
+}
+
+function hush () {
+  let debug = process.env.HEROKU_DEBUG
+  if (debug && (debug === '1' || debug.toUpperCase() === 'TRUE')) {
+    console.error.apply(null, arguments)
+  }
+}
+
+/**
+ * error is a wrapper for console.error() but can be mocked
+ *
+ * @param {...Object} obj - objects to be printed to stderr
+ */
+function error () {
+  if (mocking) {
+    cli.stderr += stripAnsi(concatArguments(arguments) + '\n')
+  } else {
+    console.error.apply(null, arguments)
+  }
+}
+
+/**
+ * writeError is a wrapper for process.stderr.write() but can be mocked
+ *
+ * @param {...Object} obj - objects to be printed to stderr
+ */
+function writeError () {
+  if (mocking) {
+    cli.stderr += stripAnsi(concatArguments(arguments))
+  } else {
+    process.stderr.write.apply(process.stderr, arguments)
+  }
+}
+
+/**
+ * mock will make {@link log} and {@link error}
+ * stop printing to stdout and stderr and start writing to the
+ * stdout and stderr strings.
+ */
+function mock (mock) {
+  if (mock === false) {
+    mocking = false
+  } else {
+    mocking = true
+    cli.stderr = ''
+    cli.stdout = ''
+  }
+}
+
+/**
+ * debug pretty prints an object.
+ * It simply calls console.dir with color enabled.
+ *
+ * @param {Object} obj - object to be printed
+ */
+function debug (obj) {
+  console.dir(obj, { colors: true })
+}
+
+exports.hush = hush
+exports.log = log
+exports.writeLog = writeLog
+exports.error = error
+exports.writeError = writeError
+exports.mock = mock
+exports.mocking = () => mocking
+exports.debug = debug

package/lib/date.js

@@ -0,0 +1,18 @@
+'use strict'
+
+/**
+ * formatDate will format a date in a standard Heroku format
+ *
+ * @example
+ * let cli = require('heroku-cli-util')
+ * var d = new Date()
+ * cli.formatDate(d); // '2015-05-14T18:03:10.034Z'
+ *
+ * @param {Date} date the date to format
+ * @return {String} string representing the date
+ */
+function formatDate (date) {
+  return date.toISOString()
+}
+
+exports.formatDate = formatDate

package/lib/errors.js

@@ -0,0 +1,122 @@
+'use strict'
+
+const stripAnsi = require('strip-ansi')
+let cli = require('..')
+let console = require('./console')
+let linewrap = require('./linewrap')
+let path = require('path')
+let os = require('os')
+
+function errtermwidth () {
+  if (global.columns) return global.columns
+  if (!process.stderr.isTTY || !process.stderr.getWindowSize) return 80
+  let width = process.stderr.getWindowSize()[0]
+  return width < 30 ? 30 : width
+}
+
+function wrap (msg) {
+  return linewrap(6,
+    errtermwidth(), {
+      skipScheme: 'ansi-color',
+      skip: /^\$ .*$/
+    })(msg || '')
+}
+
+function bangify (msg, c) {
+  let lines = msg.split('\n')
+  for (let i = 0; i < lines.length; i++) {
+    let line = lines[i]
+    lines[i] = ' ' + c + line.substr(2, line.length)
+  }
+  return lines.join('\n')
+}
+
+function getErrorMessage (err) {
+  if (err.body) {
+    // API error
+    if (err.body.message) {
+      return err.body.message
+    } else if (err.body.error) {
+      return err.body.error
+    }
+  }
+  // Unhandled error
+  if (err.message && err.code) {
+    return `${err.code}: ${err.message}`
+  } else if (err.message) {
+    return err.message
+  }
+  return err
+}
+
+let arrow = process.platform === 'win32' ? '!' : '▸'
+
+function error (err) {
+  console.error(bangify(wrap(getErrorMessage(err)), cli.color.red(arrow)))
+}
+
+function warn (msg) {
+  console.error(renderWarning(msg))
+}
+
+function renderWarning (msg) {
+  return bangify(wrap(msg), cli.color.yellow(arrow))
+}
+
+function logtimestamp () {
+  return new Date().toISOString()
+    .replace(/T/, ' ')
+    .replace(/-/g, '/')
+    .replace(/\..+/, '')
+}
+
+function cacheHome () {
+  let base
+  if (process.env.XDG_CACHE_HOME) base = process.env.XDG_CACHE_HOME
+  if (!base) {
+    if (process.platform === 'darwin') {
+      base = path.join(os.homedir(), 'Library', 'Caches')
+    } else if (process.platform === 'win32' && process.env.LOCALAPPDATA) {
+      base = process.env.LOCALAPPDATA
+    } else {
+      base = path.join(os.homedir(), '.cache')
+    }
+  }
+  return path.join(base, 'heroku')
+}
+
+function log (msg) {
+  let fs = require('fs')
+  let logPath = path.join(cacheHome(), 'error.log')
+  fs.appendFileSync(logPath, logtimestamp() + ' ' + stripAnsi(msg) + '\n')
+}
+
+function errorHandler (options) {
+  options = options || {}
+  function exit () {
+    if (options.exit !== false) {
+      process.exit(1)
+    }
+  }
+  return function handleErr (err) {
+    if (cli.raiseErrors) throw err
+    try {
+      if (err !== '') error(err)
+      if (err.stack) {
+        log(err.stack)
+        if (options.debug) console.error(err.stack)
+      }
+      if (err.body) log(JSON.stringify(err.body))
+      exit()
+    } catch (err) {
+      console.error(err.stack)
+      process.exit(-1)
+    }
+  }
+}
+
+module.exports.error = error
+module.exports.warn = warn
+module.exports.errorHandler = errorHandler
+module.exports.renderWarning = renderWarning
+module.exports.errtermwidth = errtermwidth

package/lib/exit.js

@@ -0,0 +1,42 @@
+'use strict'
+
+var util = require('util')
+var cli = require('./errors')
+
+function ErrorExit (code, message) {
+  Error.call(this)
+  Error.captureStackTrace(this, this.constructor)
+  this.name = this.constructor.name
+
+  this.code = code
+  this.message = message
+}
+
+util.inherits(ErrorExit, Error)
+
+var mocking
+
+function exit (code, message) {
+  if (message) {
+    cli.error(message)
+  }
+  if (mocking) {
+    throw new ErrorExit(code, message)
+  } else {
+    process.exit(code)
+  }
+}
+
+exit.mock = function (mock) {
+  if (mock === false) {
+    mocking = false
+  } else {
+    mocking = true
+  }
+}
+
+exit.ErrorExit = ErrorExit
+
+module.exports = {
+  exit
+}

package/lib/got.js

@@ -0,0 +1,153 @@
+'use strict'
+
+let hush = require('./console').hush
+
+function findProxy (urlParsed) {
+  let httpProxy = process.env.HTTP_PROXY || process.env.http_proxy
+  let httpsProxy = process.env.HTTPS_PROXY || process.env.https_proxy
+
+  if (urlParsed.protocol === 'https:') {
+    return httpsProxy || httpProxy
+  } else {
+    return httpProxy
+  }
+}
+
+function findTunnel (urlParsed) {
+  let tunnel = require('tunnel-agent')
+
+  if (urlParsed.protocol === 'https:') {
+    return tunnel.httpsOverHttp
+  } else {
+    return tunnel.httpOverHttp
+  }
+}
+
+function agent (urlParsed, proxyParsed, certs) {
+  let tunnelMethod = findTunnel(urlParsed)
+  let opts = {
+    proxy: {
+      host: proxyParsed.hostname,
+      port: proxyParsed.port || '8080'
+    }
+  }
+
+  if (proxyParsed.auth) {
+    opts.proxy.proxyAuth = proxyParsed.auth
+  }
+
+  if (certs.length > 0) {
+    opts.ca = certs
+  }
+
+  let tunnelAgent = tunnelMethod(opts)
+  if (urlParsed.protocol === 'https:') {
+    tunnelAgent.defaultPort = 443
+  }
+  return tunnelAgent
+}
+
+function sslCertFile () {
+  return process.env.SSL_CERT_FILE ? [process.env.SSL_CERT_FILE] : []
+}
+
+function sslCertDir () {
+  let certDir = process.env.SSL_CERT_DIR
+  if (certDir) {
+    const fs = require('fs')
+    const path = require('path')
+    return fs.readdirSync(certDir).map(f => path.join(certDir, f))
+  } else {
+    return []
+  }
+}
+
+function getCerts () {
+  let filenames = sslCertFile().concat(sslCertDir())
+
+  if (filenames.length > 0) {
+    hush('Adding the following trusted certificate authorities')
+  }
+
+  return filenames.map(function (filename) {
+    const fs = require('fs')
+    hush('  ' + filename)
+    return fs.readFileSync(filename)
+  })
+}
+
+function addToOpts (url, opts) {
+  const urlLib = require('url')
+
+  let urlParsed = urlLib.parse(url)
+  let proxy = findProxy(urlParsed)
+
+  let certs = getCerts()
+
+  if (proxy) {
+    let proxyParsed = urlLib.parse(proxy)
+    opts = Object.assign({}, opts, { agent: agent(urlParsed, proxyParsed, certs) })
+  }
+
+  if (certs.length > 0) {
+    opts = Object.assign({}, opts, { ca: certs })
+  }
+
+  return opts
+}
+
+let loadErrors
+
+function got (url, opts) {
+  const gotDelegate = require('got')
+  loadErrors()
+  return gotDelegate(url, addToOpts(url, opts))
+}
+
+got.stream = function (url, opts) {
+  const gotDelegate = require('got')
+  loadErrors()
+  return gotDelegate.stream(url, addToOpts(url, opts))
+}
+
+const helpers = [
+  'get',
+  'post',
+  'put',
+  'patch',
+  'head',
+  'delete'
+]
+
+helpers.forEach(el => {
+  got[el] = (url, opts) => got(url, Object.assign({}, opts, { method: el }))
+})
+
+helpers.forEach(el => {
+  got.stream[el] = function (url, opts) {
+    return got.stream(url, Object.assign({}, opts, { method: el }))
+  }
+})
+
+loadErrors = () => {
+  const gotDelegate = require('got')
+
+  const errors = [
+    'CacheError',
+    'CancelError',
+    'UnsupportedProtocolError',
+    'HTTPError',
+    'MaxRedirectsError',
+    'ParseError',
+    'ReadError',
+    'RequestError',
+    'TimeoutError',
+    'UploadError'
+  ]
+
+  errors.forEach(el => {
+    got[el] = gotDelegate[el]
+  })
+}
+
+module.exports = got