heroku 10.13.2-beta.0 → 11.0.0-alpha.1

package/lib/oldCommands/pipelines/promote.js

@@ -0,0 +1,269 @@
+export {};
+/*
+import color from '@heroku-cli/color'
+import {APIClient, Command, flags} from '@heroku-cli/command'
+import * as Heroku from '@heroku-cli/schema'
+import {ux} from '@oclif/core'
+import {hux} from '@heroku/heroku-cli-util'
+import * as assert from 'assert'
+import fetch from 'node-fetch'
+import * as Stream from 'stream'
+import * as util from 'util'
+
+import {AppWithPipelineCoupling, listPipelineApps} from '../../lib/api'
+import keyBy from '../../lib/pipelines/key-by'
+
+export const sleep  = (time: number) => {
+  return new Promise(resolve => setTimeout(resolve, time))
+}
+
+function assertNotPromotingToSelf(source: string, target: string) {
+  assert.notStrictEqual(source, target, `Cannot promote from an app to itself: ${target}. Specify a different target app.`)
+}
+
+function findAppInPipeline(apps: Array<AppWithPipelineCoupling>, target: string) {
+  const found = apps.find(app => (app.name === target) || (app.id === target))
+  assert(found, `Cannot find app ${color.app(target)}`)
+
+  return found
+}
+
+const PROMOTION_ORDER = ['development', 'staging', 'production']
+
+const wait = (ms = 100) => new Promise(resolve => setTimeout(resolve, ms))
+
+function isComplete(promotionTarget: Heroku.PipelinePromotionTarget) {
+  return promotionTarget.status !== 'pending'
+}
+
+function isSucceeded(promotionTarget: Heroku.PipelinePromotionTarget) {
+  return promotionTarget.status === 'succeeded'
+}
+
+function isFailed(promotionTarget: Heroku.PipelinePromotionTarget) {
+  return promotionTarget.status === 'failed'
+}
+
+function pollPromotionStatus(heroku: APIClient, id: string, needsReleaseCommand: boolean): Promise<Array<Heroku.PipelinePromotionTarget>> {
+  return heroku.get<Array<Heroku.PipelinePromotionTarget>>(`/pipeline-promotions/${id}/promotion-targets`).then(function ({body: targets}) {
+    if (targets.every(isComplete)) {
+      return targets
+    }
+
+    //
+    // With only one target, we can return as soon as the release is created.
+    // The command will then read the release phase output
+    //
+    // `needsReleaseCommand` allows us to keep polling, as it can take a few
+    // seconds to get the release to succeeded after the release command
+    // finished.
+    //
+    if (needsReleaseCommand && targets.length === 1 && targets[0].release !== null) {
+      return targets
+    }
+
+    return wait(1000).then(pollPromotionStatus.bind(null, heroku, id, needsReleaseCommand))
+  })
+}
+
+async function getCoupling(heroku: APIClient, app: string): Promise<Heroku.PipelineCoupling> {
+  ux.log('Fetching app info...')
+  const {body: coupling} = await heroku.get<Heroku.PipelineCoupling>(`/apps/${app}/pipeline-couplings`)
+  return coupling
+}
+
+async function promote(heroku: APIClient, label: string, id: string, sourceAppId: string, targetApps: Array<AppWithPipelineCoupling>, secondFactor?: string): Promise<Heroku.PipelinePromotion> {
+  const options = {
+    headers: {},
+    body: {
+      pipeline: {id},
+      source: {app: {id: sourceAppId}},
+      targets: targetApps.map(app => ({app: {id: app.id}})),
+    },
+  }
+
+  if (secondFactor) {
+    options.headers = {'Heroku-Two-Factor-Code': secondFactor}
+  }
+
+  try {
+    ux.log(`${label}...`)
+    const {body: promotions} = await heroku.post<Heroku.PipelinePromotion>('/pipeline-promotions', options)
+    return promotions
+  } catch (error: any) {
+    if (!error.body || error.body.id !== 'two_factor') {
+      throw error
+    }
+
+    const secondFactor = await heroku.twoFactorPrompt()
+    return promote(heroku, label, id, sourceAppId, targetApps, secondFactor)
+  }
+}
+
+function assertValidPromotion(app: string, source: string, target?: string) {
+  if (!target || PROMOTION_ORDER.indexOf(source) < 0) { // eslint-disable-line unicorn/prefer-includes
+    throw new Error(`Cannot promote ${app} from '${source}' stage`)
+  }
+}
+
+function assertApps(app: string, targetApps: Array<AppWithPipelineCoupling>, targetStage: string) {
+  if (targetApps.length === 0) {
+    throw new Error(`Cannot promote from ${color.app(app)} as there are no downstream apps in ${targetStage} stage`)
+  }
+}
+
+async function getRelease(heroku: APIClient, app: string, releaseId: string): Promise<Heroku.Release> {
+  ux.log('Fetching release info...')
+  const {body: release} = await heroku.get<Heroku.Release>(`/apps/${app}/releases/${releaseId}`)
+  return release
+}
+
+async function streamReleaseCommand(heroku: APIClient, targets: Array<Heroku.App>, promotion: any) {
+  if (targets.length !== 1 || targets.every(isComplete)) {
+    return pollPromotionStatus(heroku, promotion.id, false)
+  }
+
+  const target = targets[0]
+  const release = await getRelease(heroku, target.app.id, target.release.id)
+
+  if (!release.output_stream_url) {
+    return pollPromotionStatus(heroku, promotion.id, false)
+  }
+
+  ux.log('Running release command...')
+
+  async function streamReleaseOutput(releaseStreamUrl: string) {
+    const finished = util.promisify(Stream.finished)
+    const fetchResponse = await fetch(releaseStreamUrl)
+
+    if (fetchResponse.status >= 400) {
+      throw new Error('stream release output not available')
+    }
+
+    fetchResponse.body.pipe(process.stdout)
+
+    await finished(fetchResponse.body)
+  }
+
+  async function retry(maxAttempts: number, fn: () => Promise<any>) {
+    let currentAttempt = 0
+
+    while (true) {
+      try {
+        await fn()
+        return
+      } catch (error) {
+        if (++currentAttempt === maxAttempts) {
+          throw error
+        }
+
+        await sleep(1000)
+      }
+    }
+  }
+
+  await retry(100, () => {
+    return streamReleaseOutput(release.output_stream_url!)
+  })
+
+  return pollPromotionStatus(heroku, promotion.id, false)
+}
+
+export default class Promote extends Command {
+  static description = 'promote the latest release of this app to its downstream app(s)'
+
+  static examples = [
+    '$ heroku pipelines:promote -a my-app-staging',
+  ]
+
+  static flags = {
+    app: flags.app({
+      required: true,
+    }),
+    remote: flags.remote(),
+    to: flags.string({
+      char: 't',
+      description: 'comma separated list of apps to promote to',
+    }),
+  }
+
+  async run() {
+    const {flags} = await this.parse(Promote)
+    const appNameOrId = flags.app
+    const coupling = await getCoupling(this.heroku, appNameOrId)
+    ux.log(`Fetching apps from ${color.pipeline(coupling.pipeline!.name)}...`)
+    const allApps = await listPipelineApps(this.heroku, coupling.pipeline!.id!)
+    const sourceStage = coupling.stage
+
+    let promotionActionName = ''
+    let targetApps: Array<AppWithPipelineCoupling> = []
+    if (flags.to) {
+      // The user specified a specific set of apps they want to target
+      // We don't have to infer the apps or the stage they want to promote to
+
+      // Strip out any empty app names due to something like a trailing comma
+      const targetAppNames = flags.to.split(',').filter(appName => appName.length > 0)
+
+      // Now let's make sure that we can find every target app they specified
+      // The only requirement is that the app be in this pipeline. They can be at any stage.
+      targetApps = targetAppNames.reduce((acc: Array<AppWithPipelineCoupling>, targetAppNameOrId) => {
+        assertNotPromotingToSelf(appNameOrId, targetAppNameOrId)
+        const app = findAppInPipeline(allApps, targetAppNameOrId)
+        if (app) {
+          acc.push(app)
+        }
+
+        return acc
+      }, [])
+
+      promotionActionName = `Starting promotion to apps: ${targetAppNames.toString()}`
+    } else {
+      const targetStage = PROMOTION_ORDER[PROMOTION_ORDER.indexOf(sourceStage!) + 1]
+
+      assertValidPromotion(appNameOrId, sourceStage!, targetStage)
+
+      targetApps = allApps.filter(app => app.pipelineCoupling.stage === targetStage)
+
+      assertApps(appNameOrId, targetApps, targetStage)
+
+      promotionActionName = `Starting promotion to ${targetStage}`
+    }
+
+    const promotion = await promote(
+      this.heroku, promotionActionName, coupling.pipeline!.id!, coupling.app!.id!, targetApps,
+    )
+
+    const pollLoop = pollPromotionStatus(this.heroku, promotion.id!, true)
+    ux.log('Waiting for promotion to complete...')
+    let promotionTargets = await pollLoop
+
+    try {
+      promotionTargets = await streamReleaseCommand(this.heroku, promotionTargets, promotion)
+    } catch (error: any) {
+      ux.error(error)
+    }
+
+    const appsByID = keyBy(allApps, 'id')
+
+    const styledTargets = promotionTargets.reduce(function (memo: Heroku.App, target: Heroku.App) {
+      const app = appsByID[target.app.id]
+      const details = [target.status]
+
+      if (isFailed(target)) {
+        details.push(target.error_message)
+      }
+
+      memo[app.name] = details
+      return memo
+    }, {})
+
+    if (promotionTargets.every(isSucceeded)) {
+      ux.log('\nPromotion successful')
+    } else {
+      ux.warn('\nPromotion to some apps failed')
+    }
+
+    hux.styledObject(styledTargets)
+  }
+}
+*/

package/lib/oldCommands/pipelines/remove.d.ts

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

package/lib/oldCommands/pipelines/remove.js

@@ -0,0 +1,29 @@
+export {};
+/*
+import color from '@heroku-cli/color'
+import {Command, flags} from '@heroku-cli/command'
+import {ux} from '@oclif/core'
+
+import {removeCoupling} from '../../lib/api'
+
+export default class PipelinesRemove extends Command {
+  static description = 'remove this app from its pipeline'
+
+  static examples = [
+    '$ heroku pipelines:remove -a my-app',
+  ]
+
+  static flags = {
+    app: flags.app({required: true}),
+    remote: flags.remote(),
+  }
+
+  async run() {
+    const {flags: {app}} = await this.parse(PipelinesRemove)
+
+    ux.action.start(`Removing ${color.app(app)}`)
+    await removeCoupling(this.heroku, app)
+    ux.action.stop()
+  }
+}
+*/

package/lib/oldCommands/pipelines/rename.d.ts

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

package/lib/oldCommands/pipelines/rename.js

@@ -0,0 +1,42 @@
+export {};
+/*
+import color from '@heroku-cli/color'
+import {Command} from '@heroku-cli/command'
+import {Args, ux} from '@oclif/core'
+
+import {updatePipeline} from '../../lib/api'
+import disambiguate from '../../lib/pipelines/disambiguate'
+
+export default class PipelinesRename extends Command {
+  static description = 'rename a pipeline'
+
+  static examples = [
+    '$ heroku pipelines:rename my-pipeline new-pipeline-name',
+  ]
+
+  static args = {
+    pipeline: Args.string({
+      description: 'current name of pipeline',
+      required: true,
+    }),
+    name: Args.string({
+      description: 'new name of pipeline',
+      required: true,
+    }),
+  }
+
+  async run() {
+    const {args} = await this.parse(PipelinesRename)
+
+    const pipeline = await disambiguate(this.heroku, args.pipeline)
+
+    ux.action.start(`Renaming ${color.pipeline(pipeline.name!)} pipeline to ${color.pipeline(args.name)}`)
+
+    await updatePipeline(this.heroku, pipeline.id!, {
+      name: args.name,
+    })
+
+    ux.action.stop()
+  }
+}
+*/

package/lib/oldCommands/pipelines/setup.d.ts

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

package/lib/oldCommands/pipelines/setup.js

@@ -0,0 +1,117 @@
+export {};
+/*
+import color from '@heroku-cli/color'
+import {Command, flags} from '@heroku-cli/command'
+import {Args, ux} from '@oclif/core'
+import * as open from 'open'
+import Debug from 'debug'
+
+import {createPipeline, getAccountInfo, getTeam} from '../../lib/api'
+import GitHubAPI from '../../lib/pipelines/github-api'
+import KolkrabbiAPI from '../../lib/pipelines/kolkrabbi-api'
+import createApps from '../../lib/pipelines/setup/create-apps'
+import getCISettings from '../../lib/pipelines/setup/get-ci-settings'
+import getGitHubToken from '../../lib/pipelines/setup/get-github-token'
+import getNameAndRepo from '../../lib/pipelines/setup/get-name-and-repo'
+import getRepo from '../../lib/pipelines/setup/get-repo'
+import getSettings from '../../lib/pipelines/setup/get-settings'
+import pollAppSetups from '../../lib/pipelines/setup/poll-app-setups'
+import setupPipeline from '../../lib/pipelines/setup/setup-pipeline'
+import {nameAndRepo, STAGING_APP_INDICATOR} from '../../lib/pipelines/setup/validate'
+
+// eslint-disable-next-line new-cap
+const debug = Debug('pipelines:setup')
+
+export default class Setup extends Command {
+  static description =
+    'bootstrap a new pipeline with common settings and create a production and staging app (requires a fully formed app.json in the repo)'
+
+  static examples = ['$ heroku pipelines:setup my-pipeline githuborg/reponame -t my-team']
+
+  static flags = {
+    team: flags.team({
+      description: 'the team to assign pipeline ownership to (defaults to current user)',
+    }),
+
+    yes: flags.boolean({
+      char: 'y',
+      description: 'accept all default settings without prompting',
+    }),
+  }
+
+  static args = {
+    name: Args.string({
+      description: 'name of pipeline',
+      required: false,
+    }),
+    repo: Args.string({
+      description: 'a GitHub repository to connect the pipeline to',
+      required: false,
+    }),
+  }
+
+  async run() {
+    const {args, flags} = await this.parse(Setup)
+
+    const errors = nameAndRepo(args)
+
+    if (errors.length > 0) {
+      this.error(errors.join(', '))
+      return
+    }
+
+    const kolkrabbi = new KolkrabbiAPI(this.config.userAgent, () => this.heroku.auth)
+    const github = new GitHubAPI(this.config.userAgent, await getGitHubToken(kolkrabbi))
+
+    const team = flags.team
+
+    const {name: pipelineName, repo: repoName} = await getNameAndRepo(args)
+    const stagingAppName = pipelineName + STAGING_APP_INDICATOR
+    const repo = await getRepo(github, repoName)
+    const settings = await getSettings(flags.yes, repo.default_branch)
+
+    const ciSettings = await getCISettings(flags.yes, team)
+    const ownerType = team ? 'team' : 'user'
+
+    // If team or org is not specified, we assign ownership to the user creating
+    const {
+      body: {id: ownerID},
+    }: any = team ? await getTeam(this.heroku, team) : await getAccountInfo(this.heroku)
+    const owner = {id: ownerID, type: ownerType}
+
+    ux.action.start('Creating pipeline')
+    const {body: pipeline}: any = await createPipeline(this.heroku, pipelineName, owner)
+    ux.action.stop()
+
+    ux.action.start('Linking to repo')
+    await kolkrabbi.createPipelineRepository(pipeline.id, repo.id)
+    ux.action.stop()
+
+    const archiveURL = await kolkrabbi.getArchiveURL(repoName, repo.default_branch)
+
+    const appSetupsResult: any = await createApps(this.heroku, archiveURL, pipeline, pipelineName, stagingAppName, team)
+    const appSetups = appSetupsResult.map((result: any) => result.body)
+
+    ux.action.start(
+      `Creating production and staging apps (${color.app(pipelineName)} and ${color.app(stagingAppName)})`,
+    )
+    await pollAppSetups(this.heroku, appSetups)
+    ux.action.stop()
+
+    const stagingApp = appSetups.find((appSetup: any) => appSetup.app.name === stagingAppName).app
+
+    const setup = setupPipeline(kolkrabbi, stagingApp.id, settings, pipeline.id, ciSettings)
+
+    ux.action.start('Configuring pipeline')
+    try {
+      await setup
+      await open(`https://dashboard.heroku.com/pipelines/${pipeline.id}`)
+    } catch (error: any) {
+      debug(error)
+      ux.error(error)
+    } finally {
+      ux.action.stop()
+    }
+  }
+}
+*/

package/lib/oldCommands/pipelines/transfer.d.ts

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

package/lib/oldCommands/pipelines/transfer.js

@@ -0,0 +1,78 @@
+export {};
+/*
+import color from '@heroku-cli/color'
+import {APIClient, Command, flags} from '@heroku-cli/command'
+import {Args, ux} from '@oclif/core'
+import {hux} from '@heroku/heroku-cli-util'
+
+import {createPipelineTransfer, getAccountInfo, getTeam, listPipelineApps} from '../../lib/api'
+import disambiguate from '../../lib/pipelines/disambiguate'
+import renderPipeline from '../../lib/pipelines/render-pipeline'
+
+async function getTeamOwner(heroku: APIClient, name: string) {
+  const {body: team} = await getTeam(heroku, name)
+  return {id: team.id, type: 'team'}
+}
+
+async function getAccountOwner(heroku: APIClient, name: string) {
+  const {body: account} = await getAccountInfo(heroku, name)
+  return {id: account.id, type: 'user'}
+}
+
+function getOwner(heroku: APIClient, name: string) {
+  return getTeamOwner(heroku, name)
+    .catch(() => {
+      return getAccountOwner(heroku, name)
+    })
+    .catch(() => {
+      throw new Error(`Cannot find a team or account for "${name}"`)
+    })
+}
+
+export default class PipelinesTransfer extends Command {
+  static description = 'transfer ownership of a pipeline'
+
+  static examples = [
+    '$ heroku pipelines:transfer admin@example.com -p my-pipeline',
+    '$ heroku pipelines:transfer admin-team -p my-pipeline',
+  ]
+
+  static args = {
+    owner: Args.string({
+      description: 'the owner to transfer the pipeline to',
+      required: true,
+    }),
+  }
+
+  static flags = {
+    pipeline: flags.pipeline({required: true}),
+    confirm: flags.string({char: 'c'}),
+  }
+
+  async run() {
+    const {args, flags} = await this.parse(PipelinesTransfer)
+    const pipeline = await disambiguate(this.heroku, flags.pipeline)
+    const newOwner = await getOwner(this.heroku, args.owner)
+    const apps = await listPipelineApps(this.heroku, pipeline.id!)
+    const displayType = newOwner.type === 'user' ? 'account' : newOwner.type
+    let confirmName = flags.confirm
+
+    if (!confirmName) {
+      await renderPipeline(this.heroku, pipeline, apps)
+      ux.log('')
+      ux.warn(`This will transfer ${color.pipeline(pipeline.name!)} and all of the listed apps to the ${args.owner} ${displayType}`)
+      ux.warn(`to proceed, type ${color.red(pipeline.name!)} or re-run this command with ${color.red('--confirm')} ${pipeline.name}`)
+      confirmName = await hux.prompt('', {})
+    }
+
+    if (confirmName !== pipeline.name) {
+      ux.warn(`Confirmation did not match ${color.red(pipeline.name!)}. Aborted.`)
+      return
+    }
+
+    ux.action.start(`Transferring ${color.pipeline(pipeline.name!)} pipeline to the ${args.owner} ${displayType}`)
+    await createPipelineTransfer(this.heroku, {pipeline: {id: pipeline.id}, new_owner: newOwner})
+    ux.action.stop()
+  }
+}
+*/

package/lib/oldCommands/pipelines/update.d.ts

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

package/lib/oldCommands/pipelines/update.js

@@ -0,0 +1,39 @@
+export {};
+/*
+import color from '@heroku-cli/color'
+import {Command, flags} from '@heroku-cli/command'
+import {StageCompletion} from '@heroku-cli/command/lib/completions'
+import {ux} from '@oclif/core'
+
+import {updateCoupling} from '../../lib/api'
+
+export default class PipelinesUpdate extends Command {
+  static description = 'update the app\'s stage in a pipeline'
+
+  static examples = [
+    '$ heroku pipelines:update -s staging -a my-app',
+  ]
+
+  static flags = {
+    app: flags.app({required: true}),
+    remote: flags.remote(),
+    stage: flags.string({
+      char: 's',
+      description: 'new stage of app',
+      completion: StageCompletion,
+      required: true,
+    }),
+  }
+
+  async run() {
+    const {flags} = await this.parse(PipelinesUpdate)
+
+    const app = flags.app
+    const stage = flags.stage
+
+    ux.action.start(`Changing ${color.app(app)} to ${stage}`)
+    await updateCoupling(this.heroku, app, stage)
+    ux.action.stop()
+  }
+}
+*/

package/lib/oldCommands/ps/autoscale/disable.d.ts

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

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

@@ -0,0 +1,43 @@
+export {};
+/*
+import {Command, flags} from '@heroku-cli/command'
+import * as Heroku from '@heroku-cli/schema'
+import {ux} from '@oclif/core'
+
+const METRICS_HOST = 'api.metrics.heroku.com'
+
+export default class Disable extends Command {
+  static description = 'disable web dyno autoscaling'
+
+  static flags = {
+    app: flags.app({required: true}),
+    remote: flags.remote(),
+  }
+
+  async run() {
+    const {flags} = await this.parse(Disable)
+    ux.action.start('Disabling dyno autoscaling')
+
+    const appResponse = await this.heroku.get<Heroku.App>(`/apps/${flags.app}`)
+    const app = appResponse.body
+    const monitorsResponse = await this.heroku.get<Heroku.Formation>(`/apps/${app.id}/formation/web/monitors`, {
+      hostname: METRICS_HOST,
+    })
+    const monitors = monitorsResponse.body
+    const scaleMonitor = monitors.find((m: any) => m.action_type === 'scale')
+
+    if (!scaleMonitor) throw new Error(`${flags.app} does not have autoscale enabled`)
+
+    await this.heroku.patch(`/apps/${app.id}/formation/web/monitors/${scaleMonitor.id}`, {
+      hostname: METRICS_HOST,
+      body: {
+        is_active: false,
+        period: 1,
+        op: 'GREATER_OR_EQUAL',
+      },
+    })
+
+    ux.action.stop()
+  }
+}
+*/

package/lib/oldCommands/ps/autoscale/enable.d.ts

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