heroku 10.13.2 → 11.0.0-alpha.10

package/lib/oldCommands/redis/wait.js

@@ -0,0 +1,71 @@
+export {};
+/*
+import color from '@heroku-cli/color'
+import {Command, flags} from '@heroku-cli/command'
+import {Args, ux} from '@oclif/core'
+import redisApi, {RedisFormationWaitResponse} from '../../lib/redis/api'
+import {HTTPError} from '@heroku/http-call'
+
+const wait = (ms: number) => new Promise(resolve => {
+  setTimeout(resolve, ms)
+})
+
+export default class Wait extends Command {
+  static topic = 'redis';
+  static description = 'wait for Redis instance to be available';
+  static flags = {
+    'wait-interval': flags.string({description: 'how frequently to poll in seconds'}),
+    app: flags.app({required: true}),
+    remote: flags.remote(),
+  };
+
+  static args = {
+    database: Args.string({required: false, description: 'name of the Key-Value Store database. If omitted, it defaults to the primary database associated with the app.'}),
+  };
+
+  public async run(): Promise<void> {
+    const {flags, args} = await this.parse(Wait)
+    const {app, 'wait-interval': waitInterval} = flags
+    const {database} = args
+    const api = redisApi(app, database, false, this.heroku)
+    const addon = await api.getRedisAddon()
+
+    const waitFor = async () => {
+      let interval = waitInterval && Number.parseInt(waitInterval, 10)
+      if (!interval || interval < 0)
+        interval = 5
+      let status: RedisFormationWaitResponse
+      let waiting = false
+      while (true) {
+        try {
+          status = await api.request<RedisFormationWaitResponse>(`/redis/v0/databases/${addon.name}/wait`).then(response => response.body)
+        } catch (error) {
+          const httpError = error as HTTPError
+          if (httpError.statusCode !== 404)
+            throw httpError
+          status = {message: 'not found', 'waiting?': true}
+        }
+
+        if (!status['waiting?']) {
+          if (waiting) {
+            ux.action.stop(status.message)
+          }
+
+          return
+        }
+
+        if (!waiting) {
+          waiting = true
+          ux.action.start(`Waiting for database ${color.yellow(addon.name)}`, status.message)
+        }
+
+        ux.action.status = status.message
+
+        await wait(interval * 1000)
+      }
+    }
+
+    await waitFor()
+  }
+}
+*/

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

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

package/lib/oldCommands/releases/index.js

@@ -0,0 +1,156 @@
+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 {truncate} from 'lodash'
+import * as Heroku from '@heroku-cli/schema'
+import * as statusHelper from '../../lib/releases/status_helper'
+import * as time from '../../lib/time'
+import stripAnsi from 'strip-ansi'
+import {table} from '@oclif/core/lib/cli-ux/styled/table'
+import Columns = table.Columns
+
+const getDescriptionTruncation = function (releases: Heroku.Formation[], columns: Columns<Heroku.Release>, optimizeKey: string) {
+  // width management here is quite opaque.
+  // This entire function is to determine how much of Formation.description should be truncated to accommodate for Formation.status. They both go in the same column.
+  // Nothing else is truncated and the table is passed `'no-truncate': true` in options.
+  let optimizationWidth = 0
+  const optimizationWidthMap: Record<string, number> = {}
+  for (const key of Object.keys(columns)) {
+    optimizationWidthMap[key] = 0
+  }
+
+  for (const row of releases) {
+    for (const colKey in row) {
+      if (colKey === optimizeKey) {
+        continue
+      }
+
+      for (const [key, col] of Object.entries(columns)) {
+        const parts = key.split('.')
+        const matchKey = parts[0]
+        if (matchKey !== colKey) {
+          continue
+        }
+
+        let colValue = row
+        for (const part of parts) {
+          colValue = colValue[part]
+        }
+
+        let formattedValue
+        if (col.get) {
+          formattedValue = col.get(row)
+        } else {
+          formattedValue = colValue.toString()
+        }
+
+        if (key !== optimizeKey) {
+          optimizationWidthMap[key] = Math.max(
+            optimizationWidthMap[key],
+            stripAnsi(formattedValue).length,
+          )
+        }
+      }
+    }
+  }
+
+  for (const key of Object.keys(columns)) {
+    if (key !== optimizeKey) {
+      optimizationWidth += optimizationWidthMap[key] + 2
+    }
+  }
+
+  return optimizationWidth
+}
+
+export default class Index extends Command {
+  static topic = 'releases'
+  static description = 'display the releases for an app'
+  static examples = [
+    'v1 Config add FOO_BAR email@example.com 2015/11/17 17:37:41 (~ 1h ago)',
+    'v2 Config add BAR_BAZ email@example.com 2015/11/17 17:37:41 (~ 1h ago)',
+    'v3 Config add BAZ_QUX email@example.com 2015/11/17 17:37:41 (~ 1h ago)',
+  ]
+
+  static flags = {
+    num: flags.string({char: 'n', description: 'number of releases to show'}),
+    json: flags.boolean({description: 'output releases in json format'}),
+    extended: flags.boolean({char: 'x', hidden: true}),
+    remote: flags.remote(),
+    app: flags.app({required: true}),
+  }
+
+  public async run(): Promise<void> {
+    const {flags} = await this.parse(Index)
+    const {app, num, json, extended} = flags
+
+    const url = `/apps/${app}/releases${extended ? '?extended=true' : ''}`
+
+    const {body: releases} = await this.heroku.request<Heroku.Release[]>(url, {
+      partial: true,
+      headers: {
+        Range: `version ..; max=${num || 15}, order=desc`,
+        Accept: 'application/vnd.heroku+json; version=3.sdk',
+      },
+    })
+
+    let optimizationWidth = 0
+
+    const descriptionWithStatus = function (release: Heroku.Release) {
+      const {description} = release
+      const width = () => process.stdout?.columns && process.stdout.columns > 80 ? process.stdout.columns : 80
+      const trunc = (l: number, s?: string) => {
+        if (process.stdout.isTTY) {
+          return truncate(s, {length: width() - (optimizationWidth + l), omission: '…'})
+        }
+
+        return s
+      }
+
+      const status = statusHelper.description(release)
+      if (status) {
+        const sc = color[statusHelper.color(release.status)](status)
+        return trunc(status.length + 1, description) + ' ' + sc
+      }
+
+      return trunc(0, description)
+    }
+
+    const columns: Columns<Heroku.Formation> = {
+      // column name "v" as ux.table will make it's width at least "version" even though 'no-header': true
+      v: {get: release => color[statusHelper.color(release.status)]('v' + release.version)},
+      description: {get: descriptionWithStatus},
+      user: {get: ({user}) => color.magenta(user?.email || '')},
+      created_at: {get: ({created_at}) => time.ago(new Date(created_at || ''))},
+      slug_id: {extended: true, get: ({extended}) => extended?.slug_id},
+      slug_uuid: {extended: true, get: ({extended}) => extended?.slug_uuid},
+    }
+
+    // `getDescriptionTruncation` is dependent on `columns` being defined and thus `descriptionWithStatus`.
+    // `descriptionWithStatus` requires `optimizationWidth` to be defined. Redefine here before `descriptionWithStatus` is actually called.
+    optimizationWidth = getDescriptionTruncation(releases, columns, 'description')
+
+    if (json) {
+      ux.log(JSON.stringify(releases, null, 2))
+    } else if (releases.length === 0) {
+      ux.log(`${app} has no releases.`)
+    } else {
+      let header = `${app} Releases`
+      const currentRelease = releases.find(r => r.current === true)
+      if (currentRelease) {
+        header += ' - ' + color.cyan(`Current: v${currentRelease.version}`)
+      }
+
+      hux.styledHeader(header)
+      hux.table(
+        releases,
+        columns,
+        {'no-header': true, 'no-truncate': true,  extended},
+      )
+    }
+  }
+}
+*/

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

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

package/lib/oldCommands/releases/info.js

@@ -0,0 +1,68 @@
+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 * as Heroku from '@heroku-cli/schema'
+// import * as shellescape from 'shell-escape'
+import {parse, quote} from '../../lib/config/quote'
+
+const {forEach} = require('lodash')
+
+import {findByLatestOrId} from '../../lib/releases/releases'
+import {description, color as getStatusColor} from '../../lib/releases/status_helper'
+
+export default class Info extends Command {
+    static topic = 'releases';
+    static description = 'view detailed information for a release';
+    static flags = {
+      json: flags.boolean({description: 'output in json format'}),
+      shell: flags.boolean({char: 's', description: 'output in shell format'}),
+      remote: flags.remote(),
+      app: flags.app({required: true}),
+    };
+
+    static args = {
+      release: Args.string({description: 'ID of the release. If omitted, we use the last release ID.'}),
+    };
+
+    public async run(): Promise<void> {
+      const {flags, args} = await this.parse(Info)
+      const {json, shell, app} = flags
+      const release = await findByLatestOrId(this.heroku, app, args.release)
+
+      if (json) {
+        hux.styledJSON(release)
+      } else {
+        let releaseChange = release.description
+        const status = description(release)
+        const statusColor = getStatusColor(release.status)
+        const userEmail = release?.user?.email ?? ''
+        const {body: config} = await this.heroku.get<Heroku.ConfigVars>(`/apps/${app}/releases/${release.version}/config-vars`)
+
+        if (status) {
+          releaseChange += ' (' + color[statusColor](status) + ')'
+        }
+
+        hux.styledHeader(`Release ${color.cyan('v' + release.version)}`)
+        hux.styledObject({
+          'Add-ons': release.addon_plan_names,
+          Change: releaseChange,
+          By: userEmail,
+          'Eligible for Rollback?': release.eligible_for_rollback ? 'Yes' : 'No',
+          When: release.created_at,
+        })
+        ux.log()
+        hux.styledHeader(`${color.cyan('v' + release.version)} Config vars`)
+        if (shell) {
+          forEach(config, (v: string, k: string) => {
+            ux.log(`${k}=${shellescape([v])}`)
+          })
+        } else {
+          hux.styledObject(config)
+        }
+      }
+    }
+}
+*/

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

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

package/lib/oldCommands/releases/output.js

@@ -0,0 +1,42 @@
+export {};
+/*
+import {Command, flags} from '@heroku-cli/command'
+import {Args, ux} from '@oclif/core'
+import {findByLatestOrId} from '../../lib/releases/releases'
+import {stream} from '../../lib/releases/output'
+
+export default class Output extends Command {
+    static topic = 'releases';
+    static description = 'View the release command output';
+    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 release ID.'}),
+    };
+
+    public async run(): Promise<void> {
+      const {flags, args} = await this.parse(Output)
+      const {app} = flags
+      const release = await findByLatestOrId(this.heroku, app, args.release)
+      const streamUrl = release.output_stream_url
+
+      if (!streamUrl) {
+        ux.warn(`Release v${release.version} has no release output available.`)
+        return
+      }
+
+      await stream(streamUrl)
+        .catch(error => {
+          if (error.statusCode === 404 || error.response?.statusCode === 404) {
+            ux.warn('Release command not started yet. Please try again in a few seconds.')
+            return
+          }
+
+          throw error
+        })
+    }
+}
+*/

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

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

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 {};