heroku 10.13.2 → 11.0.0-alpha.2

package/lib/oldCommands/ps/autoscale/enable.js

@@ -0,0 +1,103 @@
+export {};
+/*
+import {Command, flags} from '@heroku-cli/command'
+import * as Heroku from '@heroku-cli/schema'
+import {ux} from '@oclif/core'
+import {App, Formation} from '../../../lib/types/fir'
+import {getGeneration} from '../../../lib/apps/generation'
+
+const METRICS_HOST = 'api.metrics.heroku.com'
+
+const isPerfOrPrivateTier = (size: string) => {
+  const applicableTiers = ['performance', 'private', 'shield']
+  return applicableTiers.some(tier => size.toLowerCase().includes(tier))
+}
+
+export default class Enable extends Command {
+  static description = 'enable web dyno autoscaling'
+
+  static flags = {
+    app: flags.app({required: true}),
+    remote: flags.remote(),
+    min: flags.integer({required: true, description: 'minimum number of dynos'}),
+    max: flags.integer({required: true, description: 'maximum number of dynos'}),
+    p95: flags.integer({description: 'desired p95 response time'}),
+    notifications: flags.boolean({description: 'receive email notifications when the max dyno limit is reached'}),
+  }
+
+  async run() {
+    const {flags} = await this.parse(Enable)
+    ux.action.start('Enabling dyno autoscaling')
+
+    const [appResponse, formationResponse] = await Promise.all([
+      this.heroku.get<App>(`/apps/${flags.app}`, {
+        headers: {
+          Accept: 'application/vnd.heroku+json; version=3.sdk',
+        },
+      }),
+      this.heroku.get<Formation[]>(`/apps/${flags.app}/formation`, {
+        headers: {
+          Accept: 'application/vnd.heroku+json; version=3.sdk',
+        },
+      }),
+    ])
+    const app = appResponse.body
+    const formations = formationResponse.body
+    const webFormation = formations.find((f: any) => f.type === 'web')
+
+    if (getGeneration(app) === 'fir') {
+      throw new Error('Autoscaling is unavailable for apps in this space. See https://devcenter.heroku.com/articles/generations.')
+    }
+
+    if (!webFormation) throw new Error(`${flags.app} does not have any web dynos to scale`)
+
+    const {size} = webFormation
+
+    if (!isPerfOrPrivateTier(size || '')) {
+      throw new Error('Autoscaling is only available with Performance or Private dynos')
+    }
+
+    const {body} = await this.heroku.get<Heroku.Formation[]>(`/apps/${app.id}/formation/web/monitors`, {
+      hostname: METRICS_HOST,
+    })
+    const scaleMonitor = (body || []).find((m: any) => m.action_type === 'scale')
+
+    let updatedValues: any = {
+      is_active: true,
+      action_type: 'scale',
+      notification_period: 1440,
+      op: 'GREATER_OR_EQUAL',
+      period: 1,
+      notification_channels: flags.notifications ? ['app'] : [],
+    }
+
+    if (scaleMonitor) {
+      updatedValues = {...updatedValues,
+        min_quantity: flags.min || scaleMonitor.min_quantity,
+        max_quantity: flags.max || scaleMonitor.max_quantity,
+        value: flags.p95 ? flags.p95 : scaleMonitor.value,
+      }
+
+      await this.heroku.patch(`/apps/${app.id}/formation/web/monitors/${scaleMonitor.id}`,
+        {
+          body: updatedValues,
+          hostname: METRICS_HOST,
+        })
+    } else {
+      updatedValues = {...updatedValues,
+        name: 'LATENCY_SCALE',
+        min_quantity: flags.min,
+        max_quantity: flags.max,
+        value: flags.p95 ? flags.p95 : 1000,
+      }
+
+      await this.heroku.post(`/apps/${app.id}/formation/web/monitors`, {
+        hostname: METRICS_HOST,
+        body: updatedValues,
+      })
+    }
+
+    ux.action.stop()
+  }
+}
+*/

package/lib/oldCommands/ps/index.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/oldCommands/ps/index.js

@@ -0,0 +1,254 @@
+export {};
+/*
+import color from '@heroku-cli/color'
+import {Command, flags} from '@heroku-cli/command'
+import {ux} from '@oclif/core'
+import {hux} from '@heroku/heroku-cli-util'
+import {ago} from '../../lib/time'
+import {APIClient} from '@heroku-cli/command'
+import {AccountQuota} from '../../lib/types/account_quota'
+import {AppProcessTier} from '../../lib/types/app_process_tier'
+import {DynoExtended} from '../../lib/types/dyno_extended'
+import heredoc from 'tsheredoc'
+import {Account} from '../../lib/types/fir'
+
+function getProcessNumber(s: string) : number {
+  const [processType, dynoNumber] = (s.match(/^([^.]+)\.(.*)$/) || []).slice(1, 3)
+
+  if (!processType || !dynoNumber?.match(/^\d+$/))
+    return 0
+
+  return Number.parseInt(dynoNumber, 10)
+}
+
+function uniqueValues(value: string, index: number, self: string[]) : boolean {
+  return self.indexOf(value) === index
+}
+
+function byProcessNumber(a: DynoExtended, b: DynoExtended) : number {
+  return getProcessNumber(a.name) - getProcessNumber(b.name)
+}
+
+function byProcessName(a: DynoExtended, b: DynoExtended) : number {
+  if (a.name > b.name) {
+    return 1
+  }
+
+  if (b.name > a.name) {
+    return -1
+  }
+
+  return 0
+}
+
+function byProcessTypeAndNumber(a: DynoExtended, b: DynoExtended) : number {
+  if (a.type > b.type) {
+    return 1
+  }
+
+  if (b.type > a.type) {
+    return -1
+  }
+
+  return getProcessNumber(a.name) - getProcessNumber(b.name)
+}
+
+function truncate(s: string) {
+  return s.length > 35 ? `${s.slice(0, 34)}…` : s
+}
+
+function printExtended(dynos: DynoExtended[]) {
+  const sortedDynos = dynos.sort(byProcessTypeAndNumber)
+
+  hux.table<DynoExtended>(
+    sortedDynos,
+    {
+      ID: {get: (dyno: DynoExtended) => dyno.id},
+      Process: {get: (dyno: DynoExtended) => dyno.name},
+      State: {get: (dyno: DynoExtended) => `${dyno.state} ${ago(new Date(dyno.updated_at))}`},
+      Region: {get: (dyno: DynoExtended) => dyno.extended?.region ? dyno.extended.region : ''},
+      'Execution Plane': {get: (dyno: DynoExtended) => dyno.extended?.execution_plane ? dyno.extended.execution_plane : ''},
+      Fleet: {get: (dyno: DynoExtended) => dyno.extended?.fleet ? dyno.extended.fleet : ''},
+      Instance: {get: (dyno: DynoExtended) => dyno.extended?.instance ? dyno.extended.instance : ''},
+      IP: {get: (dyno: DynoExtended) => dyno.extended?.ip ? dyno.extended.ip : ''},
+      Port: {get: (dyno: DynoExtended) => dyno.extended?.port ? dyno.extended.port.toString() : ''},
+      AZ: {get: (dyno: DynoExtended) => dyno.extended?.az ? dyno.extended.az : ''},
+      Release: {get: (dyno: DynoExtended) => dyno.release.version},
+      Command: {get: (dyno: DynoExtended) => truncate(dyno.command)},
+      Route: {get: (dyno: DynoExtended) => dyno.extended?.route ? dyno.extended.route : ''},
+      Size: {get: (dyno: DynoExtended) => dyno.size},
+    },
+    {
+      'no-truncate': true,
+    },
+  )
+}
+
+async function printAccountQuota(heroku: APIClient, app: AppProcessTier, account: Account) {
+  if (app.process_tier !== 'free' && app.process_tier !== 'eco') {
+    return
+  }
+
+  if (app.owner.id !== account.id) {
+    return
+  }
+
+  const {body: quota} = await heroku.request<AccountQuota>(
+    `/accounts/${account.id}/actions/get-quota`,
+    {headers: {Accept: 'application/vnd.heroku+json; version=3.account-quotas'}},
+  ).catch(() => {
+    return {body: null}
+  })
+
+  if (!quota || (quota.id && quota.id === 'not_found')) {
+    return
+  }
+
+  const remaining = (quota.account_quota === 0) ? 0 : quota.account_quota - quota.quota_used
+  const percentage = (quota.account_quota === 0) ? 0 : Math.floor(remaining / quota.account_quota * 100)
+  const remainingMinutes = remaining / 60
+  const hours = Math.floor(remainingMinutes / 60)
+  const minutes = Math.floor(remainingMinutes % 60)
+  const appQuota = quota.apps.find(appQuota => {
+    return appQuota.app_uuid === app.id
+  })
+  const appQuotaUsed = appQuota ? appQuota.quota_used / 60 : 0
+  const appPercentage = appQuota ? Math.floor(appQuota.quota_used * 100 / quota.account_quota) : 0
+  const appHours = Math.floor(appQuotaUsed / 60)
+  const appMinutes = Math.floor(appQuotaUsed % 60)
+
+  if (app.process_tier === 'eco') {
+    ux.log(`Eco dyno hours quota remaining this month: ${hours}h ${minutes}m (${percentage}%)`)
+    ux.log(`Eco dyno usage for this app: ${appHours}h ${appMinutes}m (${appPercentage}%)`)
+    ux.log('For more information on Eco dyno hours, see:')
+    ux.log('https://devcenter.heroku.com/articles/eco-dyno-hours')
+    ux.log()
+  }
+
+  if (app.process_tier === 'free') {
+    ux.log(`Free dyno hours quota remaining this month: ${hours}h ${minutes}m (${percentage}%)`)
+    ux.log(`Free dyno usage for this app: ${appHours}h ${appMinutes}m (${appPercentage}%)`)
+    ux.log('For more information on dyno sleeping and how to upgrade, see:')
+    ux.log('https://devcenter.heroku.com/articles/dyno-sleeping')
+    ux.log()
+  }
+}
+
+function decorateOneOffDyno(dyno: DynoExtended) : string {
+  const since = ago(new Date(dyno.updated_at))
+  // eslint-disable-next-line unicorn/explicit-length-check
+  const size = dyno.size || '1X'
+  const state = dyno.state === 'up' ? color.green(dyno.state) : color.yellow(dyno.state)
+
+  return `${dyno.name} (${color.cyan(size)}): ${state} ${color.dim(since)}: ${dyno.command}`
+}
+
+function decorateCommandDyno(dyno: DynoExtended) : string {
+  const since = ago(new Date(dyno.updated_at))
+  const state = dyno.state === 'up' ? color.green(dyno.state) : color.yellow(dyno.state)
+
+  return `${dyno.name}: ${state} ${color.dim(since)}`
+}
+
+function printDynos(dynos: DynoExtended[]) : void {
+  const oneOffs = dynos.filter(d => d.type === 'run').sort(byProcessNumber)
+  const commands = dynos.filter(d => d.type !== 'run').map(d => d.command).filter(uniqueValues)
+
+  // Print one-off dynos
+  if (oneOffs.length > 0) {
+    hux.styledHeader(`${color.green('run')}: one-off processes (${color.yellow(oneOffs.length.toString())})`)
+    oneOffs.forEach(dyno => ux.log(decorateOneOffDyno(dyno)))
+    ux.log()
+  }
+
+  // Print dynos grouped by command
+  commands.forEach(function (command) {
+    const commandDynos = dynos.filter(d => d.command === command).sort(byProcessNumber)
+    const type = commandDynos[0].type
+    // eslint-disable-next-line unicorn/explicit-length-check
+    const size = commandDynos[0].size || '1X'
+
+    hux.styledHeader(`${color.green(type)} (${color.cyan(size)}): ${command} (${color.yellow(commandDynos.length.toString())})`)
+    for (const dyno of commandDynos)
+      ux.log(decorateCommandDyno(dyno))
+    ux.log()
+  })
+}
+
+export default class Index extends Command {
+  static topic = 'ps'
+  static description = 'list dynos for an app'
+  static strict = false
+  static usage = 'ps [TYPE [TYPE ...]]'
+
+  static examples = [heredoc`
+    $ heroku ps
+    === run: one-off dyno
+    run.1: up for 5m: bash
+    === web: bundle exec thin start -p $PORT
+    web.1: created for 30s
+  `, heredoc`
+    $ heroku ps run # specifying types
+    === run: one-off dyno
+    run.1: up for 5m: bash
+  `]
+
+  static flags = {
+    app: flags.app({required: true}),
+    remote: flags.remote(),
+    json: flags.boolean({description: 'display as json'}),
+    extended: flags.boolean({char: 'x', hidden: true}), // only works with sudo privileges
+  }
+
+  public async run(): Promise<void> {
+    const {flags, ...restParse} = await this.parse(Index)
+    const {app, json, extended} = flags
+    const types = restParse.argv as string[]
+    const suffix = extended ? '?extended=true' : ''
+    const promises = {
+      dynos: this.heroku.request<DynoExtended[]>(`/apps/${app}/dynos${suffix}`, {
+        headers: {Accept: 'application/vnd.heroku+json; version=3.sdk'},
+      }),
+      appInfo: this.heroku.request<AppProcessTier>(`/apps/${app}`, {
+        headers: {Accept: 'application/vnd.heroku+json; version=3.sdk'},
+      }),
+      accountInfo: this.heroku.request<Account>('/account', {
+        headers: {Accept: 'application/vnd.heroku+json; version=3.sdk'},
+      }),
+    }
+    const [{body: dynos}, {body: appInfo}, {body: accountInfo}] = await Promise.all([promises.dynos, promises.appInfo, promises.accountInfo])
+    const shielded = appInfo.space && appInfo.space.shield
+
+    if (shielded) {
+      dynos.forEach(d => {
+        d.size = d.size.replace('Private-', 'Shield-')
+      })
+    }
+
+    let selectedDynos = dynos
+
+    if (types.length > 0) {
+      selectedDynos = selectedDynos.filter(dyno => types.find((t: string) => dyno.type === t))
+      types.forEach(t => {
+        if (!selectedDynos.some(d => d.type === t)) {
+          throw new Error(`No ${color.cyan(t)} dynos on ${color.magenta(app)}`)
+        }
+      })
+    }
+
+    selectedDynos = selectedDynos.sort(byProcessName)
+
+    if (json)
+      hux.styledJSON(selectedDynos)
+    else if (extended)
+      printExtended(selectedDynos)
+    else {
+      await printAccountQuota(this.heroku, appInfo, accountInfo)
+      if (selectedDynos.length === 0)
+        ux.log(`No dynos on ${color.magenta(app)}`)
+      else
+        printDynos(selectedDynos)
+    }
+  }
+}
+*/

package/lib/oldCommands/ps/restart.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/oldCommands/ps/restart.js

@@ -0,0 +1,78 @@
+export {};
+/*
+import {Command, flags} from '@heroku-cli/command'
+import * as Heroku from '@heroku-cli/schema'
+import color from '@heroku-cli/color'
+import {Args, ux} from '@oclif/core'
+import {ProcessTypeCompletion} from '@heroku-cli/command/lib/completions'
+import heredoc from 'tsheredoc'
+export default class Restart extends Command {
+  static description = heredoc(`
+    restart an app dyno or process type
+    if neither --dyno nor --type are specified, restarts all dynos on app
+  `)
+
+  static topic = 'ps'
+  static aliases = ['dyno:restart']
+  static hiddenAliases = ['restart']
+
+  static examples = [
+    '$ heroku ps:restart --app myapp --dyno-name web.1',
+    '$ heroku ps:restart --app myapp --process-type web',
+    '$ heroku ps:restart --app myapp',
+  ]
+
+  static args = {
+    dyno: Args.string({description: 'name of the dyno to restart', required: false, deprecated: true}),
+  }
+
+  static flags = {
+    app: flags.app({required: true}),
+    remote: flags.remote(),
+    'dyno-name': flags.string({
+      char: 'd',
+      description: 'name of the dyno to restart',
+    }),
+    'process-type': flags.string({
+      char: 'p',
+      description: 'name of the process type to restart',
+      completion: ProcessTypeCompletion,
+      exclusive: ['dyno-name'],
+    }),
+  }
+
+  async run() {
+    const {args, flags} = await this.parse(Restart)
+    const app = flags.app
+    const dyno = flags['dyno-name'] || args.dyno
+    const type = flags['process-type']
+    let msg = 'Restarting'
+    let restartUrl
+
+    if (type) {
+      msg += ` all ${color.cyan(type)} dynos`
+      restartUrl = `/apps/${app}/formations/${encodeURIComponent(type)}`
+    } else if (dyno) {
+      if (args.dyno) {
+        ux.warn(`DYNO is a deprecated argument. Use ${color.cmd('--dyno-name')} or ${color.cmd('--process-type')} instead.`)
+      }
+
+      msg += ` dyno ${color.cyan(dyno)}`
+      restartUrl = `/apps/${app}/dynos/${encodeURIComponent(dyno)}`
+    } else {
+      msg += ' all dynos'
+      restartUrl = `/apps/${app}/dynos`
+    }
+
+    msg += ` on ${color.app(app)}`
+
+    ux.action.start(msg)
+    await this.heroku.delete<Heroku.Dyno>(restartUrl, {
+      headers: {
+        Accept: 'application/vnd.heroku+json; version=3.sdk',
+      },
+    })
+    ux.action.stop()
+  }
+}
+*/

package/lib/oldCommands/ps/scale.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/oldCommands/ps/scale.js

@@ -0,0 +1,95 @@
+export {};
+/*
+import color from '@heroku-cli/color'
+import {Command, flags} from '@heroku-cli/command'
+import {ux} from '@oclif/core'
+import * as Heroku from '@heroku-cli/schema'
+import {compact} from 'lodash'
+import heredoc from 'tsheredoc'
+
+const emptyFormationErr = (app: string) => {
+  return new Error(`No process types on ${color.magenta(app)}.\nUpload a Procfile to add process types.\nhttps://devcenter.heroku.com/articles/procfile`)
+}
+
+export default class Scale extends Command {
+  static strict = false
+  static description = heredoc`
+    scale dyno quantity up or down
+    Appending a size (eg. web=2:Standard-2X) allows simultaneous scaling and resizing.
+
+    Omitting any arguments will display the app's current dyno formation, in a
+    format suitable for passing back into ps:scale.
+  `
+  static examples = [heredoc`
+    $ heroku ps:scale web=3:Standard-2X worker+1 --app APP
+    Scaling dynos... done, now running web at 3:Standard-2X, worker at 1:Standard-1X.
+  `, heredoc`
+    $ heroku ps:scale --app APP
+    web=3:Standard-2X worker=1:Standard-1X
+  `]
+
+  static aliases = ['dyno:scale']
+  static hiddenAliases = ['scale']
+  static flags = {
+    app: flags.app({required: true}),
+    remote: flags.remote(),
+  }
+
+  public async run(): Promise<void> {
+    const {flags, ...restParse} = await this.parse(Scale)
+    const argv = restParse.argv as string[]
+    const {app} = flags
+
+    function parse(args: string[]) {
+      return compact(args.map(arg => {
+        const change = arg.match(/^([\w-]+)([=+-]\d+)(?::([\w-]+))?$/)
+        if (!change)
+          return
+        const quantity = change[2][0] === '=' ? change[2].slice(1) : change[2]
+        if (change[3])
+          change[3] = change[3].replace('Shield-', 'Private-')
+        return {type: change[1], quantity, size: change[3]}
+      }))
+    }
+
+    const changes = parse(argv)
+
+    if (changes.length === 0) {
+      const {body: formation} = await this.heroku.get<Heroku.Formation[]>(`/apps/${app}/formation`)
+      const {body: appProps} = await this.heroku.get<Heroku.App>(`/apps/${app}`)
+      const shielded = appProps.space && appProps.space.shield
+      if (shielded) {
+        formation.forEach(d => {
+          if (d.size !== undefined) {
+            d.size = d.size.replace('Private-', 'Shield-')
+          }
+        })
+      }
+
+      if (formation.length === 0) {
+        throw emptyFormationErr(app)
+      }
+
+      ux.log(formation.map(d => `${d.type}=${d.quantity}:${d.size}`)
+        .sort()
+        .join(' '))
+    } else {
+      ux.action.start('Scaling dynos')
+      const {body: appProps} = await this.heroku.get<Heroku.App>(`/apps/${app}`)
+      const {body: formation} = await this.heroku.patch<Heroku.Formation[]>(`/apps/${app}/formation`, {body: {updates: changes}})
+      const shielded = appProps.space && appProps.space.shield
+      if (shielded) {
+        formation.forEach(d => {
+          if (d.size !== undefined) {
+            d.size = d.size.replace('Private-', 'Shield-')
+          }
+        })
+      }
+
+      const output = formation.filter(f => changes.find(c => c.type === f.type))
+        .map(d => `${color.green(d.type || '')} at ${d.quantity}:${d.size}`)
+      ux.action.stop(`done, now running ${output.join(', ')}`)
+    }
+  }
+}
+*/

package/lib/oldCommands/ps/stop.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/oldCommands/ps/stop.js

@@ -0,0 +1,73 @@
+export {};
+/*
+import {Command, flags} from '@heroku-cli/command'
+import * as Heroku from '@heroku-cli/schema'
+import color from '@heroku-cli/color'
+import {Args, ux} from '@oclif/core'
+import {ProcessTypeCompletion} from '@heroku-cli/command/lib/completions'
+import heredoc from 'tsheredoc'
+
+export default class Stop extends Command {
+  static description = 'stop an app dyno or process type'
+  static topic = 'ps'
+  static aliases = ['dyno:stop', 'ps:kill', 'dyno:kill']
+  static hiddenAliases = ['stop', 'kill']
+
+  static examples = [
+    '$ heroku ps:stop --app myapp --dyno-name run.1828',
+    '$ heroku ps:stop --app myapp --process-type run',
+  ]
+
+  static args = {
+    dyno: Args.string({description: 'name of the dyno to stop', required: false, deprecated: true}),
+  }
+
+  static flags = {
+    app: flags.app({required: true}),
+    remote: flags.remote(),
+    'dyno-name': flags.string({
+      char: 'd',
+      description: 'name of the dyno to stop',
+    }),
+    'process-type': flags.string({
+      char: 'p',
+      description: 'name of the process type to stop',
+      completion: ProcessTypeCompletion,
+      exclusive: ['dyno-name'],
+    }),
+  }
+
+  async run() {
+    const {args, flags} = await this.parse(Stop)
+
+    const app = flags.app
+    const dyno = flags['dyno-name'] || args.dyno
+    const type = flags['process-type']
+    let msg = 'Stopping'
+    let stopUrl = ''
+
+    if (type) {
+      msg += ` all ${color.cyan(type)} dynos`
+      stopUrl = `/apps/${app}/formations/${encodeURIComponent(type)}/actions/stop`
+    } else if (dyno) {
+      if (args.dyno) {
+        ux.warn(`DYNO is a deprecated argument. Use ${color.cmd('--dyno-name')} or ${color.cmd('--process-type')} instead.`)
+      }
+
+      msg += ` dyno ${color.cyan(dyno)}`
+      stopUrl = `/apps/${app}/dynos/${encodeURIComponent(dyno)}/actions/stop`
+    } else {
+      ux.error(heredoc(`
+        Please specify a process type or dyno name to stop.
+        See more help with --help
+      `))
+    }
+
+    msg += ` on ${color.app(app)}`
+
+    ux.action.start(msg)
+    await this.heroku.post<Heroku.Dyno>(stopUrl, {headers: {Accept: 'application/vnd.heroku+json; version=3.sdk'}})
+    ux.action.stop()
+  }
+}
+*/

package/lib/oldCommands/ps/type.d.ts

@@ -0,0 +1 @@
+export {};