heroku 10.13.2 → 11.0.0-alpha.1

package/lib/oldCommands/releases/retry.js

@@ -0,0 +1,59 @@
+export {};
+/*
+import {Command, flags} from '@heroku-cli/command'
+import {ux} from '@oclif/core'
+import color from '@heroku-cli/color'
+import * as Heroku from '@heroku-cli/schema'
+import {stream} from '../../lib/releases/output'
+import {findByLatestOrId} from '../../lib/releases/releases'
+
+export default class Retry extends Command {
+  static topic = 'releases';
+  static description = 'retry the latest release-phase command';
+  static examples = ['heroku releases:retry --app happy-samurai-42']
+  static help = 'Copies the latest release into a new release and retries the latest release-phase command. App must have a release-phase command.'
+  static flags = {
+    app: flags.app({required: true}),
+  };
+
+  public async run(): Promise<void> {
+    const {flags} = await this.parse(Retry)
+    const {app} = flags
+    const release = await findByLatestOrId(this.heroku, app)
+    const {body: formations} = await this.heroku.get<Heroku.Formation[]>(`/apps/${app}/formation`)
+    const releasePhase = formations.filter(formation => formation.type === 'release')
+
+    if (!release) {
+      return ux.error('No release found for this app.')
+    }
+
+    if (releasePhase.length === 0) {
+      return ux.error('App must have a release-phase command to use this command.')
+    }
+
+    ux.action.start(`Retrying ${color.green('v' + release.version)} on ${color.app(app)}`)
+
+    const {body: retry} = await this.heroku.post<Heroku.Release>(`/apps/${app}/releases`, {
+      body: {
+        slug: release?.slug?.id,
+        description: `Retry of v${release.version}: ${release.description}`,
+      },
+    })
+
+    ux.action.stop(`done, ${color.green('v' + retry.version)}`)
+
+    if (retry.output_stream_url) {
+      ux.log('Running release command...')
+      await stream(retry.output_stream_url)
+        .catch(error => {
+          if (error.statusCode === 404 || error.response?.statusCode === 404) {
+            ux.warn(`Release command starting. Use ${color.cmd('heroku releases:output --app ' + app)} to view the log.`)
+            return
+          }
+
+          throw error
+        })
+    }
+  }
+}
+*/

package/lib/oldCommands/releases/rollback.d.ts

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

package/lib/oldCommands/releases/rollback.js

@@ -0,0 +1,65 @@
+export {};
+/*
+import color from '@heroku-cli/color'
+import {Command, flags} from '@heroku-cli/command'
+import {Args, ux} from '@oclif/core'
+import * as Heroku from '@heroku-cli/schema'
+import {findByPreviousOrId} from '../../lib/releases/releases'
+import {stream} from '../../lib/releases/output'
+
+export default class Rollback extends Command {
+  static topic = 'releases'
+  static hiddenAliases = ['rollback']
+  static description = `Roll back to a previous release.
+
+    If RELEASE is not specified, it will roll back to the last eligible release.
+    `
+  static flags = {
+    remote: flags.remote(),
+    app: flags.app({required: true}),
+  }
+
+  static args = {
+    release: Args.string({description: 'ID of the release. If omitted, we use the last eligible release.'}),
+  }
+
+  public async run(): Promise<void> {
+    const {flags, args} = await this.parse(Rollback)
+    const {app} = flags
+    const release = await findByPreviousOrId(this.heroku, app, args.release)
+
+    if (!release) {
+      ux.error(`No eligible release found for ${color.app(app)} to roll back to.`)
+    }
+
+    ux.action.start(`Rolling back ${color.app(app)} to ${color.green('v' + release.version)}`)
+    const {body: latest} = await this.heroku.post<Heroku.Release>(`/apps/${app}/releases`, {
+      body: {
+        release: release.id,
+      },
+      headers: {
+        Accept: 'application/vnd.heroku+json; version=3.sdk',
+      },
+    })
+    const streamUrl = latest.output_stream_url
+    ux.action.stop(`done, ${color.green('v' + latest.version)}`)
+    ux.warn("Rollback affects code and config vars; it doesn't add or remove addons.")
+    if (latest.version) {
+      ux.warn(`To undo, run: ${color.cyan.bold('heroku rollback v' + (latest.version - 1))}`)
+    }
+
+    if (streamUrl) {
+      ux.log('Running release command...')
+      await stream(streamUrl)
+        .catch(error => {
+          if (error.statusCode === 404 || error.response?.statusCode === 404) {
+            ux.warn('Release command starting. Use `heroku releases:output` to view the log.')
+            return
+          }
+
+          throw error
+        })
+    }
+  }
+}
+*/

package/lib/oldCommands/run/detached.d.ts

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

package/lib/oldCommands/run/detached.js

@@ -0,0 +1,61 @@
+export {};
+/*
+import color from '@heroku-cli/color'
+import {Command, flags} from '@heroku-cli/command'
+import {DynoSizeCompletion, ProcessTypeCompletion} from '@heroku-cli/command/lib/completions'
+import {ux} from '@oclif/core'
+import Dyno from '../../lib/run/dyno'
+import {buildCommand} from '../../lib/run/helpers'
+import logDisplayer from '../../lib/run/log-displayer'
+
+export default class RunDetached extends Command {
+  static description = 'run a detached dyno, where output is sent to your logs'
+
+  static examples = [
+    '$ heroku run:detached ls',
+  ]
+
+  static strict = false
+
+  static flags = {
+    app: flags.app({required: true}),
+    remote: flags.remote(),
+    env: flags.string({char: 'e', description: "environment variables to set (use ';' to split multiple vars)"}),
+    size: flags.string({char: 's', description: 'dyno size', completion: DynoSizeCompletion}),
+    tail: flags.boolean({char: 't', description: 'continually stream logs'}),
+    type: flags.string({description: 'process type', completion: ProcessTypeCompletion}),
+  }
+
+  async run() {
+    const {flags, argv} = await this.parse(RunDetached)
+
+    const opts = {
+      heroku: this.heroku,
+      app: flags.app,
+      command: buildCommand(argv as string[]),
+      size: flags.size,
+      type: flags.type,
+      env: flags.env,
+      attach: false,
+    }
+
+    if (!opts.command) {
+      throw new Error('Usage: heroku run COMMAND\n\nExample: heroku run bash')
+    }
+
+    const dyno = new Dyno(opts)
+
+    await dyno.start()
+
+    if (flags.tail) {
+      await logDisplayer(this.heroku, {
+        app: flags.app,
+        dyno: dyno.dyno?.name,
+        tail: true,
+      })
+    } else {
+      ux.log(`Run ${color.cmd(`heroku logs --app ${dyno.opts.app} --dyno ${dyno.dyno?.name || ''}`)} to view the output.`)
+    }
+  }
+}
+*/

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

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

package/lib/oldCommands/run/index.js

@@ -0,0 +1,72 @@
+export {};
+/*
+import {Command, flags} from '@heroku-cli/command'
+import {DynoSizeCompletion, ProcessTypeCompletion} from '@heroku-cli/command/lib/completions'
+import {ux} from '@oclif/core'
+import debugFactory from 'debug'
+import * as Heroku from '@heroku-cli/schema'
+import Dyno from '../../lib/run/dyno'
+import {buildCommand, revertSortedArgs} from '../../lib/run/helpers'
+
+const debug = debugFactory('heroku:run')
+
+export default class Run extends Command {
+  static description = 'run a one-off process inside a heroku dyno\nShows a notification if the dyno takes more than 20 seconds to start.'
+
+  static examples = [
+    '$ heroku run bash',
+    '$ heroku run -s standard-2x -- myscript.sh -a arg1 -s arg2',
+  ]
+
+  // This is to allow for variable length arguments
+  static strict = false
+
+  static flags = {
+    app: flags.app({description: 'parent app used by review apps', required: true}),
+    remote: flags.remote(),
+    size: flags.string({char: 's', description: 'dyno size', completion: DynoSizeCompletion}),
+    type: flags.string({description: 'process type', completion: ProcessTypeCompletion}),
+    'exit-code': flags.boolean({char: 'x', description: 'passthrough the exit code of the remote command'}),
+    env: flags.string({char: 'e', description: "environment variables to set (use ';' to split multiple vars)"}),
+    'no-tty': flags.boolean({description: 'force the command to not run in a tty'}),
+    listen: flags.boolean({description: 'listen on a local port', hidden: true}),
+    'no-notify': flags.boolean({description: 'disables notification when dyno is up (alternatively use HEROKU_NOTIFICATIONS=0)'}),
+  }
+
+  async run() {
+    const {argv, flags} = await this.parse(Run)
+    const command = revertSortedArgs(process.argv, argv as string[])
+    const opts = {
+      'exit-code': flags['exit-code'],
+      'no-tty': flags['no-tty'],
+      app: flags.app,
+      attach: true,
+      command: buildCommand(command),
+      env: flags.env,
+      heroku: this.heroku,
+      listen: flags.listen,
+      notify: !flags['no-notify'],
+      size: flags.size,
+      type: flags.type,
+    }
+
+    if (!opts.command) {
+      throw new Error('Usage: heroku run COMMAND\n\nExample: heroku run bash')
+    }
+
+    await this.heroku.get<Heroku.Account>('/account')
+    const dyno = new Dyno(opts)
+    try {
+      await dyno.start()
+      debug('done running')
+    } catch (error: any) {
+      debug(error)
+      if (error.exitCode) {
+        ux.error(error.message, {code: error.exitCode, exit: error.exitCode})
+      } else {
+        throw error
+      }
+    }
+  }
+}
+*/

package/lib/oldCommands/run/inside.d.ts

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

package/lib/oldCommands/run/inside.js

@@ -0,0 +1,93 @@
+export {};
+/*
+import {Command, flags} from '@heroku-cli/command'
+import {Args, ux} from '@oclif/core'
+import debugFactory from 'debug'
+import heredoc from 'tsheredoc'
+import Dyno from '../../lib/run/dyno'
+import {buildCommand} from '../../lib/run/helpers'
+import {App} from '../../lib/types/fir'
+
+const debug = debugFactory('heroku:run:inside')
+
+export default class RunInside extends Command {
+  static description = 'run a command inside an existing dyno (for Fir-generation apps only)'
+
+  static strict = false
+  static args = {
+    dyno_name: Args.string({
+      description: 'name of the dyno to run command inside',
+      required: true,
+    }),
+    command: Args.string({
+      description: 'command to run (Heroku automatically prepends ‘launcher’ to the command)',
+      required: true,
+    }),
+  }
+
+  static flags = {
+    app: flags.app({required: true}),
+    'exit-code': flags.boolean({
+      char: 'x',
+      description: 'passthrough the exit code of the remote command',
+    }),
+    listen: flags.boolean({description: 'listen on a local port', hidden: true}),
+    'no-launcher': flags.boolean({
+      description: 'don’t prepend ‘launcher’ before a command',
+      default: false,
+    }),
+    remote: flags.remote(),
+  }
+
+  static examples = [
+    heredoc`
+      Run bash
+      heroku run:inside web-848cd4f64d-pvpr2 bash -a my-app
+    `,
+    heredoc`
+      Run a command supplied by a script taking option flags
+      heroku run:inside web-848cd4f64d-pvpr2 -a my-app -- myscript.sh -x --log-level=warn
+    `,
+    heredoc`
+      Run a command declared for the worker process type in a Procfile
+      heroku run:inside web-848cd4f64d-pvpr2 worker -a my-app
+    `,
+  ]
+
+  async run() {
+    const {args, argv, flags} = await this.parse(RunInside)
+
+    const {dyno_name: dynoName} = args
+    const {app: appName, 'exit-code': exitCode, listen, 'no-launcher': noLauncher} = flags
+    const prependLauncher = !noLauncher
+
+    const {body: app} = await this.heroku.get<App>(
+      `/apps/${appName}`, {
+        headers: {Accept: 'application/vnd.heroku+json; version=3.sdk'},
+      })
+    const appStackIsCnb = app.stack.name === 'cnb'
+
+    const opts = {
+      app: appName,
+      command: buildCommand(argv.slice(1) as string[], appStackIsCnb && prependLauncher),
+      dyno: dynoName,
+      'exit-code': exitCode,
+      heroku: this.heroku,
+      listen,
+    }
+
+    const dyno = new Dyno(opts)
+
+    try {
+      await dyno.start()
+    } catch (error: any) {
+      debug(error)
+      if (error.exitCode) {
+        ux.exit(error.exitCode)
+      } else {
+        throw error
+      }
+    }
+  }
+}
+*/

package/lib/oldCommands/spaces/create.d.ts

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

package/lib/oldCommands/spaces/create.js

@@ -0,0 +1,99 @@
+export {};
+/*
+import color from '@heroku-cli/color'
+import {Command, flags} from '@heroku-cli/command'
+import {Args, ux} from '@oclif/core'
+import {hux} from '@heroku/heroku-cli-util'
+import {Space} from '../../lib/types/fir'
+import heredoc from 'tsheredoc'
+import {displayShieldState} from '../../lib/spaces/spaces'
+import {RegionCompletion} from '../../lib/autocomplete/completions'
+import {splitCsv} from '../../lib/spaces/parsers'
+import {getGeneration} from '../../lib/apps/generation'
+
+export default class Create extends Command {
+  static topic = 'spaces'
+  static description = heredoc`
+    create a new space
+  `
+  static examples = [heredoc`
+    Example:
+
+    $ heroku spaces:create --space my-space --team my-team --region oregon
+    Creating space my-space in team my-team... done
+    === my-space
+    ID:         e7b99e37-69b3-4475-ad47-a5cc5d75fd9f
+    Team:       my-team
+    Region:     oregon
+    CIDR:       10.0.0.0/16
+    Data CIDR:  172.23.0.0/20
+    State:      allocating
+    Generation: cedar
+    Created at: 2016-01-06T03:23:13Z
+  `]
+
+  static flags = {
+    channel: flags.string({hidden: true}),
+    cidr: flags.string({description: 'RFC-1918 CIDR the space will use'}),
+    'data-cidr': flags.string({description: 'RFC-1918 CIDR used by Heroku Data resources for the space'}),
+    features: flags.string({hidden: true, description: 'a list of features separated by commas'}),
+    generation: flags.string({description: 'generation for space', default: 'cedar', options: ['cedar', 'fir']}),
+    'kpi-url': flags.string({hidden: true, description: 'self-managed KPI endpoint to use'}),
+    'log-drain-url': flags.string({hidden: true, description: 'direct log drain url'}),
+    region: flags.string({description: 'region name', completion: RegionCompletion}),
+    shield: flags.boolean({hidden: true, description: 'create a Shield space'}),
+    space: flags.string({char: 's', description: 'name of space to create'}),
+    team: flags.team({required: true}),
+  }
+
+  static args = {
+    space: Args.string({hidden: true}),
+  }
+
+  public async run(): Promise<void> {
+    const {flags, args} = await this.parse(Create)
+    const {channel, region, features, generation, 'log-drain-url': logDrainUrl, shield, cidr, 'kpi-url': kpiUrl, 'data-cidr': dataCidr, team} = flags
+    const spaceName = flags.space || args.space
+
+    if (!spaceName) {
+      ux.error(heredoc`
+        Space name required.
+        USAGE: heroku spaces:create --space my-space --team my-team
+      `)
+    }
+
+    const dollarAmountMonthly = shield ? '$3000' : '$1000'
+    const dollarAmountHourly = shield ? '$4.17' : '$1.39'
+    const spaceType = shield ? 'Shield' : 'Standard'
+
+    ux.action.start(`Creating space ${color.green(spaceName as string)} in team ${color.cyan(team as string)}`)
+    const {body: space} = await this.heroku.post<Required<Space>>('/spaces', {
+      headers: {
+        Accept: 'application/vnd.heroku+json; version=3.sdk',
+      },
+      body: {
+        channel_name: channel,
+        cidr,
+        data_cidr: dataCidr,
+        features: splitCsv(features),
+        generation,
+        kpi_url: kpiUrl,
+        log_drain_url: logDrainUrl,
+        name: spaceName,
+        region,
+        shield,
+        team,
+      },
+    })
+    ux.action.stop()
+
+    ux.warn(`${color.bold('Spend Alert.')} Each Heroku ${spaceType} Private Space costs ~${dollarAmountHourly}/hour (max ${dollarAmountMonthly}/month), pro-rated to the second.`)
+    ux.warn(`Use ${color.cmd('heroku spaces:wait')} to track allocation.`)
+
+    hux.styledHeader(space.name)
+    hux.styledObject({
+      ID: space.id, Team: space.team.name, Region: space.region.name, CIDR: space.cidr, 'Data CIDR': space.data_cidr, State: space.state, Shield: displayShieldState(space), Generation: getGeneration(space), 'Created at': space.created_at,
+    }, ['ID', 'Team', 'Region', 'CIDR', 'Data CIDR', 'State', 'Shield', 'Generation', 'Created at'])
+  }
+}
+*/

package/lib/oldCommands/spaces/destroy.d.ts

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

package/lib/oldCommands/spaces/destroy.js

@@ -0,0 +1,79 @@
+export {};
+/*
+import {Args, ux} from '@oclif/core'
+import {Command, flags} from '@heroku-cli/command'
+import * as Heroku from '@heroku-cli/schema'
+import heredoc from 'tsheredoc'
+import confirmCommand from '../../lib/confirmCommand'
+import {displayNat} from '../../lib/spaces/spaces'
+import color from '@heroku-cli/color'
+import {Space} from '../../lib/types/fir'
+import {getGeneration} from '../../lib/apps/generation'
+
+type RequiredSpaceWithNat = Required<Space> & {outbound_ips?: Required<Heroku.SpaceNetworkAddressTranslation>}
+
+export default class Destroy extends Command {
+  static topic = 'spaces'
+  static description = heredoc`
+    destroy a space
+  `
+  static examples = [heredoc`
+    $ heroku spaces:destroy --space my-space
+    Destroying my-space... done
+  `]
+
+  static flags = {
+    space: flags.string({char: 's', description: 'space to destroy'}),
+    confirm: flags.string({description: 'set to space name to bypass confirm prompt', hasValue: true}),
+  }
+
+  static args = {
+    space: Args.string({hidden: true}),
+  }
+
+  public async run(): Promise<void> {
+    const {flags, args} = await this.parse(Destroy)
+    const {confirm} = flags
+    const spaceName = flags.space || args.space
+    if (!spaceName) {
+      ux.error(heredoc`
+        Space name required.
+        USAGE: heroku spaces:destroy my-space
+      `)
+    }
+
+    let natWarning = ''
+    const {body: space} = await this.heroku.get<RequiredSpaceWithNat>(`/spaces/${spaceName}`)
+
+    if (space.state === 'allocated') {
+      ({body: space.outbound_ips} = await this.heroku.get<Required<Heroku.SpaceNetworkAddressTranslation>>(`/spaces/${spaceName}/nat`))
+      if (space.outbound_ips && space.outbound_ips.state === 'enabled') {
+        const ipv6 = getGeneration(space) === 'fir' ? ' and IPv6' : ''
+        natWarning = heredoc`
+        ${color.dim('===')} ${color.bold('WARNING: Outbound IPs Will Be Reused')}
+        ${color.yellow(`⚠️ Deleting this space frees up the following outbound IPv4${ipv6} IPs for reuse:`)}
+        ${color.bold(displayNat(space.outbound_ips) ?? '')}
+
+        ${color.dim('Update the following configurations:')}
+        ${color.dim('=')} IP allowlists
+        ${color.dim('=')} Firewall rules
+        ${color.dim('=')} Security group configurations
+        ${color.dim('=')} Network ACLs
+
+        ${color.yellow(`Ensure that you remove the listed IPv4${ipv6} addresses from your security configurations.`)}
+      `
+      }
+    }
+
+    await confirmCommand(
+      spaceName as string,
+      confirm,
+      `Destructive Action\nThis command will destroy the space ${color.bold.red(spaceName as string)}\n${natWarning}\n`,
+    )
+
+    ux.action.start(`Destroying space ${color.cyan(spaceName as string)}`)
+    await this.heroku.delete(`/spaces/${spaceName}`)
+    ux.action.stop()
+  }
+}
+*/

package/lib/oldCommands/spaces/drains/get.d.ts

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

package/lib/oldCommands/spaces/drains/get.js

@@ -0,0 +1,33 @@
+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'
+
+export default class Get extends Command {
+  static topic = 'spaces'
+  static aliases = ['drains:get']
+  static hidden = true
+  static description = 'display the log drain for a space'
+  static flags = {
+    space: flags.string({char: 's', description: 'space for which to get log drain', required: true}),
+    json: flags.boolean({description: 'output in json format'}),
+  }
+
+  public async run(): Promise<void> {
+    const {flags} = await this.parse(Get)
+    const {space, json} = flags
+    const {body: drain} = await this.heroku.get<Required<Heroku.LogDrain>>(
+      `/spaces/${space}/log-drain`,
+      {headers: {Accept: 'application/vnd.heroku+json; version=3.dogwood'}},
+    )
+
+    if (json) {
+      ux.log(JSON.stringify(drain, null, 2))
+    } else {
+      ux.log(`${color.cyan(drain.url)} (${color.green(drain.token)})`)
+    }
+  }
+}
+*/

package/lib/oldCommands/spaces/drains/set.d.ts

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

package/lib/oldCommands/spaces/drains/set.js

@@ -0,0 +1,33 @@
+export {};
+/*
+import color from '@heroku-cli/color'
+import {Command, flags} from '@heroku-cli/command'
+import {Args, ux} from '@oclif/core'
+import * as Heroku from '@heroku-cli/schema'
+
+export default class Set extends Command {
+  static topic = 'spaces'
+  static aliases = ['drains:set']
+  static hidden = true
+  static description = 'replaces the log drain for a space'
+  static flags = {
+    space: flags.string({char: 's', description: 'space for which to set log drain', required: true}),
+  }
+
+  static args = {
+    url: Args.string({required: true, description: 'URL to replace the log drain with'}),
+  }
+
+  public async run(): Promise<void> {
+    const {flags, args} = await this.parse(Set)
+    const {url} = args
+    const {space} = flags
+    const {body: drain} = await this.heroku.put<Heroku.LogDrain>(`/spaces/${space}/log-drain`, {
+      body: {url},
+      headers: {Accept: 'application/vnd.heroku+json; version=3.dogwood'},
+    })
+    ux.log(`Successfully set drain ${color.cyan(drain.url)} for ${color.cyan.bold(space)}.`)
+    ux.warn('It may take a few moments for the changes to take effect.')
+  }
+}
+*/

package/lib/oldCommands/spaces/hosts.d.ts

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

package/lib/oldCommands/spaces/hosts.js

@@ -0,0 +1,42 @@
+export {};
+/*
+import {Command, flags} from '@heroku-cli/command'
+import {Args, ux} from '@oclif/core'
+import heredoc from 'tsheredoc'
+import {displayHostsAsJSON, displayHosts, type Host} from '../../lib/spaces/hosts'
+
+export default class Hosts extends Command {
+  static topic = 'spaces'
+  static hidden = true
+  static description = 'list dedicated hosts for a space'
+  static flags = {
+    space: flags.string({char: 's', description: 'space to get host list from'}),
+    json: flags.boolean({description: 'output in json format'}),
+  }
+
+  static args = {
+    space: Args.string({hidden: true}),
+  }
+
+  public async run(): Promise<void> {
+    const {flags, args} = await this.parse(Hosts)
+    const spaceName = flags.space || args.space
+    if (!spaceName) {
+      ux.error(heredoc(`
+        Error: Missing 1 required arg:
+        space
+        See more help with --help
+      `))
+    }
+
+    const {body: hosts} = await this.heroku.get<Host[]>(
+      `/spaces/${spaceName}/hosts`, {
+        headers: {Accept: 'application/vnd.heroku+json; version=3.dogwood'},
+      })
+    if (flags.json)
+      displayHostsAsJSON(hosts)
+    else
+      displayHosts(spaceName as string, hosts)
+  }
+}
+*/

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

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