@heroku/heroku-cli-util 8.0.12

package/LICENSE

@@ -0,0 +1,3 @@
+Copyright (c) 2016, Heroku
+Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies.
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package/README.md

@@ -0,0 +1,269 @@
+# Heroku CLI Utilities
+
+![GitHub Actions CI](https://github.com/heroku/heroku-cli-util/actions/workflows/ci.yml/badge.svg)
+[![npm version](https://badge.fury.io/js/heroku-cli-util.svg)](http://badge.fury.io/js/heroku-cli-util)
+[![License](https://img.shields.io/github/license/heroku/heroku-cli-util.svg)](https://github.com/heroku/heroku-cli-util/blob/master/LICENSE)
+
+Set of helpful CLI utilities
+
+## Installation
+
+```sh
+npm install heroku-cli-util --save
+```
+
+## Action
+
+```js
+let cli = require('heroku-cli-util');
+await cli.action('restarting dynos', async function() {
+  let app = await heroku.get(`/apps/${context.app}`);
+  await heroku.request({method: 'DELETE', path: `/apps/${app.name}/dynos`});
+});
+
+// restarting dynos... done
+```
+
+## Prompt
+
+```js
+let cli   = require('heroku-cli-util');
+let email = await cli.prompt('email', {});
+console.log(`your email is: ${email}`);
+```
+
+**cli.prompt options**
+
+```js
+cli.prompt('email', {
+  mask: true, // mask input field after submitting
+  hide: true // mask characters while entering
+});
+```
+
+## Confirm App
+
+Supports the same async styles as `prompt()`. Errors if not confirmed.
+
+Basic
+
+```js
+let cli = require('heroku-cli-util');
+await cli.confirmApp('appname', context.flags.confirm);
+
+// !     WARNING: Destructive Action
+// !     This command will affect the app appname
+// !     To proceed, type appname or re-run this command with --confirm appname
+
+> appname
+```
+
+Custom message
+
+```js
+let cli = require('heroku-cli-util');
+await cli.confirmApp('appname', context.flags.confirm, 'foo');
+
+// !     foo
+// !     To proceed, type appname or re-run this command with --confirm appname
+
+> appname
+```
+
+Note that you will still need to define a `confirm` flag for your command.
+
+## Errors
+
+```js
+let cli = require('heroku-cli-util');
+cli.error("App not found");
+// !    App not found
+```
+
+## Warnings
+
+```js
+let cli = require('heroku-cli-util');
+cli.warn("App not found");
+// !    App not found
+```
+
+## Dates
+
+```js
+let cli = require('heroku-cli-util');
+let d   = new Date();
+console.log(cli.formatDate(d));
+// 2001-01-01T08:00:00.000Z
+```
+
+## Hush
+
+Use hush for verbose logging when `HEROKU_DEBUG=1`.
+
+```js
+let cli = require('heroku-cli-util');
+cli.hush('foo');
+// only prints if HEROKU_DEBUG is set
+```
+
+## Debug
+
+Pretty print an object.
+
+```js
+let cli = require('heroku-cli-util');
+cli.debug({foo: [1,2,3]});
+// { foo: [ 1, 2, 3 ] }
+```
+
+## Stylized output
+
+Pretty print a header, hash, and JSON
+```js
+let cli = require('heroku-cli-util');
+cli.styledHeader("MyApp");
+cli.styledHash({name: "myapp", collaborators: ["user1@example.com", "user2@example.com"]});
+cli.styledJSON({name: "myapp"});
+```
+
+Produces
+
+```
+=== MyApp
+Collaborators: user1@example.com
+               user1@example.com
+Name:          myapp
+
+{
+  "name": "myapp"
+}
+```
+
+## Table
+
+```js
+cli.table([
+  {app: 'first-app',  language: 'ruby', dyno_count: 3},
+  {app: 'second-app', language: 'node', dyno_count: 2},
+], {
+  columns: [
+    {key: 'app'},
+    {key: 'dyno_count', label: 'Dyno Count'},
+    {key: 'language', format: language => cli.color.red(language)},
+  ]
+});
+```
+
+Produces:
+
+```
+app         Dyno Count  language
+──────────  ──────────  ────────
+first-app   3           ruby
+second-app  2           node
+```
+
+## Linewrap
+
+Used to indent output with wrapping around words:
+
+```js
+cli.log(cli.linewrap(2, 10, 'this is text is longer than 10 characters'));
+// Outputs:
+//
+// this
+// text is
+//  longer
+//  than 10
+//  characters`);
+```
+
+Useful with `process.stdout.columns || 80`.
+
+## Open Web Browser
+
+```js
+await cli.open('https://github.com');
+```
+
+## HTTP calls
+
+`heroku-cli-util` includes an instance of [got](https://www.npmjs.com/package/got) that will correctly use HTTP proxies.
+
+```js
+let cli = require('heroku-cli-util');
+let rsp = await cli.got('https://google.com');
+```
+
+## Mocking
+
+Mock stdout and stderr by using `cli.log()` and `cli.error()`.
+
+```js
+let cli = require('heroku-cli-util');
+cli.log('message 1'); // prints 'message 1'
+cli.mockConsole();
+cli.log('message 2'); // prints nothing
+cli.stdout.should.eq('message 2\n');
+```
+
+## Command
+
+Used for initializing a plugin command.
+give you an auth'ed instance of `heroku-client` and cleanly handle API exceptions.
+
+It expects you to return a promise chain. This is usually done with [co](https://github.com/tj/co).
+
+```js
+let cli = require('heroku-cli-util');
+let co  = require('co');
+module.exports.commands = [
+  {
+    topic: 'apps',
+    command: 'info',
+    needsAuth: true,
+    needsApp: true,
+    run: cli.command(async function (context, heroku) {
+      let app = await heroku.get(`/apps/${context.app}`);
+      console.dir(app);
+    })
+  }
+];
+```
+
+With options:
+
+```js
+let cli = require('heroku-cli-util');
+let co  = require('co');
+module.exports.commands = [
+  {
+    topic: 'apps',
+    command: 'info',
+    needsAuth: true,
+    needsApp: true,
+    run: cli.command(
+      {preauth: true},
+      async function (context, heroku) {
+        let app = await heroku.get(`/apps/${context.app}`);
+        console.dir(app);
+      }
+    )
+  }
+];
+```
+
+If the command has a `two_factor` API error, it will ask the user for a 2fa code and retry.
+If you set `preauth: true` it will preauth against the current app instead of just setting the header on an app. (This is necessary if you need to do more than 1 API call that will require 2fa)
+
+## Tests
+
+```sh
+npm install
+npm test
+```
+
+## License
+
+ISC

package/index.js

@@ -0,0 +1,40 @@
+'use strict'
+
+exports.color = require('@heroku-cli/color').default
+
+var console = require('./lib/console')
+var errors = require('./lib/errors')
+var prompt = require('./lib/prompt')
+var styled = require('./lib/styled')
+
+exports.hush = console.hush
+exports.log = console.log.bind(console)
+exports.formatDate = require('./lib/date').formatDate
+exports.error = errors.error
+exports.action = require('./lib/action')
+exports.warn = exports.action.warn
+exports.errorHandler = errors.errorHandler
+exports.console = console
+exports.yubikey = require('./lib/yubikey')
+exports.prompt = prompt.prompt
+exports.confirmApp = prompt.confirmApp
+exports.preauth = require('./lib/preauth')
+exports.command = require('./lib/command')
+exports.debug = console.debug
+exports.mockConsole = console.mock
+exports.table = require('./lib/table')
+exports.stdout = ''
+exports.stderr = ''
+exports.styledHeader = styled.styledHeader
+exports.styledObject = styled.styledObject
+exports.styledHash = styled.styledObject
+exports.styledNameValues = styled.styledNameValues
+exports.styledJSON = styled.styledJSON
+exports.open = require('./lib/open')
+exports.got = require('./lib/got')
+exports.linewrap = require('./lib/linewrap')
+exports.Spinner = require('./lib/spinner')
+exports.exit = require('./lib/exit').exit
+exports.auth = require('./lib/auth')
+exports.login = exports.auth.login
+exports.logout = exports.auth.logout

package/lib/action.js

@@ -0,0 +1,54 @@
+'use strict'
+
+let cli = require('..')
+let errors = require('./errors')
+
+function start (message, options) {
+  if (!options) options = {}
+  module.exports.task = {
+    spinner: new cli.Spinner({ spinner: options.spinner, text: `${message}...` }),
+    stream: options.stream
+  }
+  module.exports.task.spinner.start()
+}
+
+function action (message, options, promise) {
+  if (options.then) [options, promise] = [{}, options]
+  start(message, options)
+  return promise.then(function (result) {
+    if (options.success !== false) done(options.success || 'done', options)
+    else done(null, options)
+    return result
+  }).catch(function (err) {
+    if (err.body && err.body.id === 'two_factor') done(cli.color.yellow.bold('!'), options)
+    else done(cli.color.red.bold('!'), options)
+    throw err
+  })
+}
+
+function warn (msg) {
+  let task = module.exports.task
+  if (task) task.spinner.warn(msg)
+  else errors.warn(msg)
+}
+
+function status (status) {
+  let task = module.exports.task
+  if (task) task.spinner.status = status
+}
+
+function done (msg, options) {
+  options = options || {}
+  let task = module.exports.task
+  if (task) {
+    task.spinner.stop(msg)
+    module.exports.task = null
+    if (options.clear) task.spinner.clear()
+  }
+}
+
+module.exports = action
+module.exports.start = start
+module.exports.warn = warn
+module.exports.status = status
+module.exports.done = done

package/lib/auth.js

@@ -0,0 +1,207 @@
+'use strict'
+
+const cli = require('..')
+const vars = require('./vars')
+
+function basicAuth (username, password) {
+  let auth = [username, password].join(':')
+  auth = Buffer.from(auth).toString('base64')
+  return `Basic ${auth}`
+}
+
+function createOAuthToken (username, password, expiresIn, secondFactor) {
+  const os = require('os')
+
+  let headers = {
+    Authorization: basicAuth(username, password)
+  }
+
+  if (secondFactor) headers['Heroku-Two-Factor-Code'] = secondFactor
+
+  return cli.heroku.post('/oauth/authorizations', {
+    headers,
+    body: {
+      scope: ['global'],
+      description: `Heroku CLI login from ${os.hostname()} at ${new Date()}`,
+      expires_in: expiresIn || 60 * 60 * 24 * 365 // 1 year
+    }
+  }).then(function (auth) {
+    return { token: auth.access_token.token, email: auth.user.email, expires_in: auth.access_token.expires_in }
+  })
+}
+
+function saveToken ({ email, token }) {
+  const netrc = require('netrc-parser').default
+  netrc.loadSync()
+  const hosts = [vars.apiHost, vars.httpGitHost]
+  hosts.forEach(host => {
+    if (!netrc.machines[host]) netrc.machines[host] = {}
+    netrc.machines[host].login = email
+    netrc.machines[host].password = token
+  })
+  if (netrc.machines._tokens) {
+    netrc.machines._tokens.forEach(token => {
+      if (hosts.includes(token.host)) {
+        token.internalWhitespace = '\n  '
+      }
+    })
+  }
+  netrc.saveSync()
+}
+
+async function loginUserPass ({ save, expires_in: expiresIn }) {
+  const { prompt } = require('./prompt')
+
+  cli.log('Enter your Heroku credentials:')
+  let email = await prompt('Email')
+  let password = await prompt('Password', { hide: true })
+
+  let auth
+  try {
+    auth = await createOAuthToken(email, password, expiresIn)
+  } catch (err) {
+    if (!err.body || err.body.id !== 'two_factor') throw err
+    let secondFactor = await prompt('Two-factor code', { mask: true })
+    auth = await createOAuthToken(email, password, expiresIn, secondFactor)
+  }
+  if (save) saveToken(auth)
+  return auth
+}
+
+async function loginSSO ({ save, browser }) {
+  const { prompt } = require('./prompt')
+
+  let url = process.env['SSO_URL']
+  if (!url) {
+    let org = process.env['HEROKU_ORGANIZATION']
+    if (!org) {
+      org = await prompt('Enter your organization name')
+    }
+    url = `https://sso.heroku.com/saml/${encodeURIComponent(org)}/init?cli=true`
+  }
+
+  const open = require('./open')
+
+  let openError
+  await cli.action('Opening browser for login', open(url, browser)
+    .catch(function (err) {
+      openError = err
+    })
+  )
+
+  if (openError) {
+    cli.console.error(openError.message)
+  }
+
+  let token = await prompt('Enter your access token (typing will be hidden)', { hide: true })
+
+  let account = await cli.heroku.get('/account', {
+    headers: {
+      Authorization: `Bearer ${token}`
+    }
+  })
+
+  if (save) saveToken({ token, email: account.email })
+  return { token: token, email: account.email }
+}
+
+async function logout () {
+  let token = cli.heroku.options.token
+  if (token) {
+    // for SSO logins we delete the session since those do not show up in
+    // authorizations because they are created a trusted client
+    let sessionsP = cli.heroku.delete('/oauth/sessions/~')
+      .catch(err => {
+        if (err.statusCode === 404 && err.body && err.body.id === 'not_found' && err.body.resource === 'session') {
+          return null
+        }
+        if (err.statusCode === 401 && err.body && err.body.id === 'unauthorized') {
+          return null
+        }
+        throw err
+      })
+
+    // grab the default authorization because that is the token shown in the
+    // dashboard as API Key and they may be using it for something else and we
+    // would unwittingly break an integration that they are depending on
+    let defaultAuthorizationP = cli.heroku.get('/oauth/authorizations/~')
+      .catch(err => {
+        if (err.statusCode === 404 && err.body && err.body.id === 'not_found' && err.body.resource === 'authorization') {
+          return null
+        }
+        if (err.statusCode === 401 && err.body && err.body.id === 'unauthorized') {
+          return null
+        }
+        throw err
+      })
+
+    // grab all the authorizations so that we can delete the token they are
+    // using in the CLI.  we have to do this rather than delete ~ because
+    // the ~ is the API Key, not the authorization that is currently requesting
+    let authorizationsP = cli.heroku.get('/oauth/authorizations')
+      .catch(err => {
+        if (err.statusCode === 401 && err.body && err.body.id === 'unauthorized') {
+          return []
+        }
+        throw err
+      })
+
+    let [, defaultAuthorization, authorizations] = await Promise.all([sessionsP, defaultAuthorizationP, authorizationsP])
+
+    if (accessToken(defaultAuthorization) !== token) {
+      for (let authorization of authorizations) {
+        if (accessToken(authorization) === token) {
+          // remove the matching access token from core services
+          await cli.heroku.delete(`/oauth/authorizations/${authorization.id}`)
+        }
+      }
+    }
+  }
+
+  const netrc = require('netrc-parser').default
+  netrc.loadSync()
+  if (netrc.machines[vars.apiHost]) {
+    netrc.machines[vars.apiHost] = undefined
+  }
+  if (netrc.machines[vars.httpGitHost]) {
+    netrc.machines[vars.httpGitHost] = undefined
+  }
+  netrc.saveSync()
+}
+
+function accessToken (authorization) {
+  return authorization && authorization.access_token && authorization.access_token.token
+}
+
+async function login (options = {}) {
+  if (!options.skipLogout) await logout()
+
+  try {
+    if (options['sso']) {
+      return await loginSSO(options)
+    } else {
+      return await loginUserPass(options)
+    }
+  } catch (e) {
+    const { PromptMaskError } = require('./prompt')
+    const os = require('os')
+    if (e instanceof PromptMaskError && os.platform() === 'win32') {
+      throw new PromptMaskError('Login is currently incompatible with git bash/Cygwin/MinGW')
+    } else {
+      throw e
+    }
+  }
+}
+
+function token () {
+  const netrc = require('netrc-parser').default
+  netrc.loadSync()
+  if (process.env.HEROKU_API_KEY) return process.env.HEROKU_API_KEY
+  return netrc.machines[vars.apiHost] && netrc.machines[vars.apiHost].password
+}
+
+module.exports = {
+  login: login,
+  logout: logout,
+  token
+}