heroku 10.13.2 → 11.0.0-alpha.2

package/lib/oldCommands/ps/type.js

@@ -0,0 +1,190 @@
+export {};
+/*
+import color from '@heroku-cli/color'
+import {APIClient, Command, flags} from '@heroku-cli/command'
+import {ux} from '@oclif/core'
+import {hux} from '@heroku/heroku-cli-util'
+import * as Heroku from '@heroku-cli/schema'
+import {sortBy, compact} from 'lodash'
+import heredoc from 'tsheredoc'
+
+const COST_MONTHLY: Record<string, number> = {
+  Free: 0,
+  Eco: 0,
+  Hobby: 7,
+  Basic: 7,
+  'Standard-1X': 25,
+  'Standard-2X': 50,
+  'Performance-M': 250,
+  Performance: 500,
+  'Performance-L': 500,
+  '1X': 36,
+  '2X': 72,
+  PX: 576,
+  'Performance-L-RAM': 500,
+  'Performance-XL': 750,
+  'Performance-2XL': 1500,
+  'Private-S': 225,
+  'Private-M': 450,
+  'Private-L': 900,
+  'Shield-M': 540,
+  'Shield-L': 1080,
+  'Shield-S': 270,
+  'Private-Memory-L': 500,
+  'Private-Memory-XL': 750,
+  'Private-Memory-2XL': 1500,
+  'Shield-Memory-L': 600,
+  'Shield-Memory-XL': 900,
+  'Shield-Memory-2XL': 1800,
+  'dyno-1c-0.5gb': 25,
+  'dyno-2c-1gb': 50,
+  'dyno-1c-4gb': 80,
+  'dyno-2c-8gb': 160,
+  'dyno-4c-16gb': 320,
+  'dyno-8c-32gb': 640,
+  'dyno-16c-64gb': 1000,
+  'dyno-2c-4gb': 150,
+  'dyno-4c-8gb': 300,
+  'dyno-8c-16gb': 600,
+  'dyno-16c-32gb': 1200,
+  'dyno-32c-64gb': 2400,
+  'dyno-1c-8gb': 100,
+  'dyno-2c-16gb': 250,
+  'dyno-4c-32gb': 500,
+  'dyno-8c-64gb': 750,
+  'dyno-16c-128gb': 1500,
+}
+
+const calculateHourly =  (size: string) => COST_MONTHLY[size] / 720
+
+const emptyFormationErr = (app: string) => {
+  return new Error(`No process types on ${app}.\nUpload a Procfile to add process types.\nhttps://devcenter.heroku.com/articles/procfile`)
+}
+
+const displayFormation = async (heroku: APIClient, app: string) => {
+  const {body: formation} = await heroku.get<Heroku.Formation[]>(`/apps/${app}/formation`)
+  const {body: appProps} = await heroku.get<Heroku.App>(`/apps/${app}`)
+  const shielded = appProps.space && appProps.space.shield
+  const dynoTotals: Record<string, number> = {}
+  let isShowingEcoCostMessage = false
+
+  const formationTableData = sortBy(formation, 'type')
+    // this filter shouldn't be necessary, but it makes TS happy
+    .filter((f): f is Heroku.Formation & {size: string, quantity: number} => typeof f.size === 'string' && typeof f.quantity === 'number')
+    .map((d => {
+      if (d.size === 'Eco') {
+        isShowingEcoCostMessage = true
+      }
+
+      if (shielded) {
+        d.size = d.size.replace('Private-', 'Shield-')
+      }
+
+      if (d.size in dynoTotals) {
+        dynoTotals[d.size] += d.quantity
+      } else {
+        dynoTotals[d.size] = d.quantity
+      }
+
+      return {
+        // this rule does not realize `size` isn't used on an array
+        type: color.green(d.type || ''),
+        size: color.cyan(d.size),
+        qty: color.yellow(`${d.quantity}`),
+        'cost/hour': calculateHourly(d.size) ?
+          '~$' + (calculateHourly(d.size) * (d.quantity || 1)).toFixed(3)
+            .toString() :
+          '',
+        'max cost/month': COST_MONTHLY[d.size] ?
+          // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+          // @ts-ignore
+          '$' + (COST_MONTHLY[d.size] * d.quantity).toString() :
+          '',
+      }
+    }))
+
+  const dynoTotalsTableData = Object.keys(dynoTotals)
+    .map(k => ({
+      type: color.green(k), total: color.yellow((dynoTotals[k]).toString()),
+    }))
+
+  if (formation.length === 0) {
+    throw emptyFormationErr(app)
+  }
+
+  hux.styledHeader('Process Types')
+  hux.table(formationTableData, {
+    type: {},
+    size: {},
+    qty: {},
+    'cost/hour': {},
+    'max cost/month': {},
+  })
+  ux.log()
+  hux.styledHeader('Dyno Totals')
+  hux.table(dynoTotalsTableData, {
+    type: {},
+    total: {},
+  })
+
+  if (isShowingEcoCostMessage) {
+    ux.log('\n$5 (flat monthly fee, shared across all Eco dynos)')
+  }
+}
+
+export default class Type extends Command {
+  static strict = false
+  static description = heredoc`
+    manage dyno sizes
+    Called with no arguments shows the current dyno size.
+
+    Called with one argument sets the size.
+    Where SIZE is one of eco|basic|standard-1x|standard-2x|performance
+
+    Called with 1..n TYPE=SIZE arguments sets the quantity per type.
+  `
+  static aliases = ['ps:resize', 'dyno:resize']
+  static hiddenAliases = ['resize', 'dyno:type']
+  static flags = {
+    app: flags.app({required: true}),
+    remote: flags.remote(),
+  }
+
+  public async run(): Promise<void> {
+    const {flags, ...restParse} = await this.parse(Type)
+    const argv = restParse.argv as string[]
+    const {app} = flags
+
+    const parse = async () => {
+      if (!argv || argv.length === 0)
+        return []
+      const {body: formation} = await this.heroku.get<Heroku.Formation[]>(`/apps/${app}/formation`)
+      if (argv.some(a => a.match(/=/))) {
+        return compact(argv.map(arg => {
+          const match = arg.match(/^([a-zA-Z0-9_]+)=([\w-]+)$/)
+          const type = match && match[1]
+          const size = match && match[2]
+          if (!type || !size || !formation.some(p => p.type === type)) {
+            throw new Error(`Type ${color.red(type || '')} not found in process formation.\nTypes: ${color.yellow(formation.map(f => f.type)
+              .join(', '))}`)
+          }
+
+          return {type, size}
+        }))
+      }
+
+      return formation.map(p => ({type: p.type, size: argv[0]}))
+    }
+
+    const changes = await parse()
+
+    if (changes.length > 0) {
+      ux.action.start(`Scaling dynos on ${color.magenta(app)}`)
+      await this.heroku.patch(`/apps/${app}/formation`, {body: {updates: changes}})
+      ux.action.stop()
+    }
+
+    await displayFormation(this.heroku, app)
+  }
+}
+*/

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

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

package/lib/oldCommands/ps/wait.js

@@ -0,0 +1,93 @@
+export {};
+/*
+import {Command, flags} from '@heroku-cli/command'
+import {ux} from '@oclif/core'
+import {hux} from '@heroku/heroku-cli-util'
+
+import {Dyno, Release} from '@heroku-cli/schema'
+
+export default class Wait extends Command {
+  static description = 'wait for all dynos to be running latest version after a release'
+
+  static flags = {
+    app: flags.app({required: true}),
+    remote: flags.remote(),
+    type: flags.string({
+      char: 't',
+      description: 'wait for one specific dyno type',
+    }),
+    'wait-interval': flags.integer({
+      char: 'w',
+      description: 'how frequently to poll in seconds (to avoid hitting Heroku API rate limits)',
+      parse: async input => {
+        const w = Number.parseInt(input, 10)
+        if (w < 10) {
+          ux.error('wait-interval must be at least 10', {exit: 1})
+        }
+
+        return w
+      },
+      default: 10,
+    }),
+    'with-run': flags.boolean({
+      char: 'R',
+      description: 'whether to wait for one-off run dynos',
+      exclusive: ['type'],
+    }),
+  }
+
+  async run() {
+    const {flags} = await this.parse(Wait)
+
+    const {body: releases} = await this.heroku.request<Release[]>(`/apps/${flags.app}/releases`, {
+      partial: true,
+      headers: {
+        Range: 'version ..; max=1, order=desc',
+      },
+    })
+
+    if (releases.length === 0) {
+      this.warn(`App ${flags.app} has no releases`)
+      return
+    }
+
+    const latestRelease = releases[0]
+
+    let released = true
+    const interval = flags['wait-interval'] as number
+
+    while (1 as any) {
+      const {body: dynos} = await this.heroku.get<Dyno[]>(`/apps/${flags.app}/dynos`)
+      const relevantDynos = dynos
+        .filter(dyno => dyno.type !== 'release')
+        .filter(dyno => flags['with-run'] || dyno.type !== 'run')
+        .filter(dyno => !flags.type || dyno.type === flags.type)
+
+      const onLatest = relevantDynos.filter((dyno: Dyno) => {
+        return dyno.state === 'up' &&
+          latestRelease.version !== undefined &&
+          dyno.release !== undefined &&
+          dyno.release.version !== undefined &&
+          dyno.release.version >= latestRelease.version
+      })
+      const releasedFraction = `${onLatest.length} / ${relevantDynos.length}`
+      if (onLatest.length === relevantDynos.length) {
+        if (!released) {
+          ux.action.stop(`${releasedFraction}, done`)
+        }
+
+        break
+      }
+
+      if (released) {
+        released = false
+        ux.action.start(`Waiting for every dyno to be running v${latestRelease.version}`)
+      }
+
+      ux.action.status = releasedFraction
+
+      await hux.wait(interval * 1000)
+    }
+  }
+}
+*/

package/lib/oldCommands/redis/cli.d.ts

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

package/lib/oldCommands/redis/cli.js

@@ -0,0 +1,227 @@
+export {};
+/*
+import {APIClient, Command, flags} from '@heroku-cli/command'
+import {Args, ux} from '@oclif/core'
+import * as Heroku from '@heroku-cli/schema'
+import * as readline from 'readline'
+import {Client} from 'ssh2'
+import Parser = require('redis-parser')
+import type {Writable} from 'node:stream'
+import portfinder = require('portfinder')
+import confirmCommand from '../../lib/confirmCommand'
+import * as tls from 'tls'
+import type {Socket} from 'node:net'
+import type {Duplex} from 'stream'
+import {promisify} from 'node:util'
+import * as net from 'net'
+import type {RedisFormationResponse} from '../../lib/redis/api'
+import apiFactory from '../../lib/redis/api'
+
+const REPLY_OK = 'OK'
+
+async function redisCLI(uri: URL, client: Writable): Promise<void> {
+  const io = readline.createInterface(process.stdin, process.stdout)
+  const reply = new Parser({
+    returnReply(reply) {
+      switch (state) {
+      case 'monitoring':
+        if (reply !== REPLY_OK) {
+          console.log(reply)
+        }
+
+        break
+      case 'subscriber':
+        if (Array.isArray(reply)) {
+          reply.forEach(function (value, i) {
+            console.log(`${i + 1}) ${value}`)
+          })
+        } else {
+          console.log(reply)
+        }
+
+        break
+      case 'connect':
+        if (reply !== REPLY_OK) {
+          console.log(reply)
+        }
+
+        state = 'normal'
+        io.prompt()
+        break
+      case 'closing':
+        if (reply !== REPLY_OK) {
+          console.log(reply)
+        }
+
+        break
+      default:
+        if (Array.isArray(reply)) {
+          reply.forEach(function (value, i) {
+            console.log(`${i + 1}) ${value}`)
+          })
+        } else {
+          console.log(reply)
+        }
+
+        io.prompt()
+        break
+      }
+    }, returnError(err) {
+      console.log(err.message)
+      io.prompt()
+    }, returnFatalError(err) {
+      client.emit('error', err)
+      console.dir(err)
+    },
+  })
+  let state = 'connect'
+  client.write(`AUTH ${uri.password}\n`)
+  io.setPrompt(uri.host + '> ')
+  io.on('line', function (line) {
+    switch (line.split(' ')[0]) {
+    case 'MONITOR':
+      state = 'monitoring'
+      break
+    case 'PSUBSCRIBE':
+    case 'SUBSCRIBE':
+      state = 'subscriber'
+      break
+    }
+
+    client.write(`${line}\n`)
+  })
+  io.on('close', function () {
+    state = 'closing'
+    client.write('QUIT\n')
+  })
+  client.on('data', function (data) {
+    reply.execute(data)
+  })
+  return new Promise((resolve, reject) => {
+    client.on('error', reject)
+    client.on('end', function () {
+      console.log('\nDisconnected from instance.')
+      io.close()
+      resolve()
+    })
+  })
+}
+
+async function bastionConnect(uri: URL, bastions: string, config: Record<string, unknown>, preferNativeTls: boolean) {
+  const tunnel: Client = await new Promise(resolve => {
+    const ssh2 = new Client()
+    ssh2.once('ready', () => resolve(ssh2))
+    ssh2.connect({
+      host: bastions.split(',')[0],
+      username: 'bastion',
+      privateKey: match(config, /_BASTION_KEY/) ?? '',
+    })
+  })
+  const localPort = await portfinder.getPortPromise({startPort: 49152, stopPort: 65535})
+  const stream: Duplex = await promisify(tunnel.forwardOut.bind(tunnel))('localhost', localPort, uri.hostname, Number.parseInt(uri.port, 10))
+
+  let client: Duplex = stream
+  if (preferNativeTls) {
+    client = tls.connect({
+      socket: stream as Socket,
+      port: Number.parseInt(uri.port, 10),
+      host: uri.hostname,
+      rejectUnauthorized: false,
+    })
+  }
+
+  stream.on('close', () => tunnel.end())
+  stream.on('end', () => client.end())
+
+  return redisCLI(uri, client)
+}
+
+function match(config: Record<string, unknown>, lookup: RegExp): string | null {
+  for (const key in config) {
+    if (lookup.test(key)) {
+      return config[key] as string
+    }
+  }
+
+  return null
+}
+
+async function maybeTunnel(redis: RedisFormationResponse, config: Record<string, unknown>) {
+  const bastions = match(config, /_BASTIONS/)
+  const hobby = redis.plan.indexOf('hobby') === 0
+  const preferNativeTls = redis.prefer_native_tls
+  const uri = preferNativeTls && hobby ? new URL(match(config, /_TLS_URL/) ?? '') : new URL(redis.resource_url)
+
+  if (bastions !== null) {
+    return bastionConnect(uri, bastions, config, preferNativeTls)
+  }
+
+  let client
+  if (preferNativeTls) {
+    client = tls.connect({
+      port: Number.parseInt(uri.port, 10), host: uri.hostname, rejectUnauthorized: false,
+    })
+  } else if (hobby) {
+    client = net.connect({port: Number.parseInt(uri.port, 10), host: uri.hostname})
+  } else {
+    client = tls.connect({
+      port: Number.parseInt(uri.port, 10) + 1, host: uri.hostname, rejectUnauthorized: false,
+    })
+  }
+
+  return redisCLI(uri, client)
+}
+
+export default class Cli extends Command {
+  static topic = 'redis'
+  static description = 'opens a redis prompt'
+  static flags = {
+    confirm: flags.string({char: 'c'}),
+    app: flags.app({required: true}),
+    remote: flags.remote(),
+  }
+
+  static args = {
+    database: Args.string({description: 'name of the Key-Value Store database. If omitted, it defaults to the primary database associated with the app.', ignoreStdin: true}),
+  }
+
+  static examples = [
+    '$ heroku redis:cli --app=my-app my-database',
+    '$ heroku redis:cli --app=my-app --confirm my-database',
+  ]
+
+  public async run(): Promise<void> {
+    const {flags, args} = await this.parse(Cli)
+    const api = apiFactory(flags.app, args.database, false, this.heroku)
+    const addon = await api.getRedisAddon()
+    const configVars = await getRedisConfigVars(addon, this.heroku)
+    const {body: redis} = await api.request<RedisFormationResponse>(`/redis/v0/databases/${addon.id}`)
+    if (redis.plan.startsWith('shield-')) {
+      ux.error('\n      Using redis:cli on Heroku Redis shield plans is not supported.\n      Please see Heroku DevCenter for more details: https://devcenter.heroku.com/articles/shield-private-space#shield-features\n      ', {exit: 1})
+    }
+
+    const hobby = redis.plan.indexOf('hobby') === 0
+    const prefer_native_tls = redis.prefer_native_tls
+    if (!prefer_native_tls && hobby) {
+      await confirmCommand(flags.app, flags.confirm, 'WARNING: Insecure action.\nAll data, including the Redis password, will not be encrypted.')
+    }
+
+    const nonBastionVars = Object.keys(configVars)
+      .filter(function (configVar) {
+        return !(/(?:BASTIONS|BASTION_KEY|BASTION_REKEYS_AFTER)$/.test(configVar))
+      })
+      .join(', ')
+    ux.log(`Connecting to ${addon.name} (${nonBastionVars}):`)
+    return maybeTunnel(redis, configVars)
+  }
+}
+
+async function getRedisConfigVars(addon: Required<Heroku.AddOn>, heroku: APIClient): Promise<Record<string, unknown>> {
+  const {body: config} = await heroku.get<Record<string, unknown>>(`/apps/${addon.billing_entity.name}/config-vars`)
+  const redisConfigVars: Record<string, unknown> = {}
+  addon.config_vars.forEach(configVar => {
+    redisConfigVars[configVar] = config[configVar]
+  })
+  return redisConfigVars
+}
+*/

package/lib/oldCommands/redis/credentials.d.ts

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

package/lib/oldCommands/redis/credentials.js

@@ -0,0 +1,36 @@
+export {};
+/*
+import {Command, flags} from '@heroku-cli/command'
+import {Args, ux} from '@oclif/core'
+import redisApi, {RedisFormationResponse} from '../../lib/redis/api'
+
+export default class Credentials extends Command {
+  static topic = 'redis'
+  static description = 'display credentials information'
+  static flags = {
+    app: flags.app({required: true}),
+    remote: flags.remote(),
+    reset: flags.boolean({description: 'reset credentials'}),
+  }
+
+  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.'}),
+  }
+
+  async run() {
+    const {args, flags} = await this.parse(Credentials)
+    const {app, reset} = flags
+    const {database} = args
+
+    const addon = await redisApi(app, database, false, this.heroku).getRedisAddon()
+
+    if (reset) {
+      ux.log(`Resetting credentials for ${addon.name}`)
+      await redisApi(app, database, false, this.heroku).request(`/redis/v0/databases/${addon.name}/credentials_rotation`, 'POST', {})
+    } else {
+      const {body: redis} = await redisApi(app, database, false, this.heroku).request<RedisFormationResponse>(`/redis/v0/databases/${addon.name}`)
+      ux.log(redis.resource_url)
+    }
+  }
+}
+*/

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

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

package/lib/oldCommands/redis/info.js

@@ -0,0 +1,28 @@
+export {};
+/*
+import {Command, flags} from '@heroku-cli/command'
+import {Args} from '@oclif/core'
+import redisApi from '../../lib/redis/api'
+
+export default class Info extends Command {
+  static topic = 'redis'
+  static description = 'gets information about redis'
+  static aliases = ['redis']
+  static flags = {
+    app: flags.app({required: true}),
+    remote: flags.remote(),
+    json: flags.boolean({char: 'j', description: 'output in json format'}),
+  }
+
+  static args = {
+    database: Args.string({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(Info)
+    const {app, json} = flags
+    const {database} = args
+    return redisApi(app, database, json, this.heroku).info()
+  }
+}
+*/

package/lib/oldCommands/redis/keyspace-notifications.d.ts

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

package/lib/oldCommands/redis/keyspace-notifications.js

@@ -0,0 +1,55 @@
+export {};
+/*
+import {Command, flags} from '@heroku-cli/command'
+import {Args} from '@oclif/core'
+import redisApi, {RedisFormationConfigResponse} from '../../lib/redis/api'
+import heredoc from 'tsheredoc'
+import {ux} from '@oclif/core'
+
+export default class KeyspaceNotifications extends Command {
+  static topic = 'redis'
+  static description = heredoc`
+    set the keyspace notifications configuration
+    Set the configuration to enable keyspace notification events:
+    K     Keyspace events, published with __keyspace@<db>__ prefix.
+    E     Keyevent events, published with __keyevent@<db>__ prefix.
+    g     Generic commands (non-type specific) like DEL, EXPIRE, RENAME, ...
+    $     String commands
+    l     List commands
+    s     Set commands
+    h     Hash commands
+    z     Sorted set commands
+    t     Stream commands
+    x     Expired events (events generated every time a key expires)
+    e     Evicted events (events generated when a key is evicted for maxmemory)
+    m     Key miss events (events generated when a key that doesn't exist is accessed)
+    A     Alias for "g$lshztxe", so that the "AKE" string means all the events except "m".
+
+    pass an empty string ('') to disable keyspace notifications
+  `
+
+  static flags = {
+    app: flags.app({required: true}),
+    remote: flags.remote(),
+    config: flags.string({char: 'c', description: 'set keyspace notifications configuration', hasValue: true, required: true}),
+  }
+
+  static args = {
+    database: Args.string({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(KeyspaceNotifications)
+    const {app, config} = flags
+    const {database} = args
+    const api = redisApi(app, database, false, this.heroku)
+
+    const addon = await api.getRedisAddon()
+
+    const {body: updated_config} = await api.request<RedisFormationConfigResponse>(
+      `/redis/v0/databases/${addon.name}/config`, 'PATCH', {notify_keyspace_events: config},
+    )
+    ux.log(`Keyspace notifications for ${addon.name} (${addon.config_vars.join(', ')}) set to '${updated_config.notify_keyspace_events.value}'.`)
+  }
+}
+*/

package/lib/oldCommands/redis/maintenance.d.ts

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