heroku 10.13.2 → 11.0.0-alpha.10

package/lib/oldCommands/spaces/vpn/connections.js

@@ -0,0 +1,70 @@
+export {};
+/*
+import {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 heredoc from 'tsheredoc'
+import {displayVPNStatus} from '../../../lib/spaces/format'
+
+type VpnConnectionTunnels = Required<Heroku.PrivateSpacesVpn>['tunnels']
+
+export default class Connections extends Command {
+  static topic = 'spaces'
+  static description = 'list the VPN Connections for a space'
+  static example = heredoc`
+    $ heroku spaces:vpn:connections --space my-space
+    === my-space VPN Connections
+     Name   Status Tunnels
+     ────── ────── ───────
+     office active UP/UP
+  `
+  static flags = {
+    space: flags.string({char: 's', description: 'space to get VPN connections from', required: true}),
+    json: flags.boolean({description: 'output in json format'}),
+  }
+
+  public async run(): Promise<void> {
+    const {flags} = await this.parse(Connections)
+    const {space, json} = flags
+    const {body: connections} = await this.heroku.get<Required<Heroku.PrivateSpacesVpn>[]>(`/spaces/${space}/vpn-connections`)
+    this.render(space, connections, json)
+  }
+
+  protected render(space: string, connections: Required<Heroku.PrivateSpacesVpn>[], json: boolean) {
+    if (json) {
+      hux.styledJSON(connections)
+    } else {
+      this.displayVPNConnections(space, connections)
+    }
+  }
+
+  protected displayVPNConnections(space: string, connections: Required<Heroku.PrivateSpacesVpn>[]) {
+    if (connections.length === 0) {
+      ux.log('No VPN Connections have been created yet')
+      return
+    }
+
+    hux.styledHeader(`${space} VPN Connections`)
+
+    hux.table(
+      connections,
+      {
+        Name: {
+          get: c => c.name || c.id,
+        },
+        Status: {
+          get: c => displayVPNStatus(c.status),
+        },
+        Tunnels: {
+          get: c => this.tunnelFormat(c.tunnels),
+        },
+      },
+    )
+  }
+
+  protected tunnelFormat(t: VpnConnectionTunnels) {
+    return t.map(tunnel => displayVPNStatus(tunnel.status)).join('/')
+  }
+}
+*/

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

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

package/lib/oldCommands/spaces/vpn/destroy.js

@@ -0,0 +1,48 @@
+export {};
+/*
+import color from '@heroku-cli/color'
+import {Command, flags} from '@heroku-cli/command'
+import {Args, ux} from '@oclif/core'
+import confirmCommand from '../../../lib/confirmCommand'
+import heredoc from 'tsheredoc'
+
+export default class Destroy extends Command {
+  static topic = 'spaces'
+  static description = 'destroys VPN in a private space'
+  static examples = [heredoc`
+    $ heroku spaces:vpn:destroy vpn-connection-name --space example-space --confirm vpn-connection-name
+    Tearing down VPN Connection vpn-connection-name in space example-space
+  `]
+
+  static flags = {
+    space: flags.string({char: 's', description: 'space name', required: true}),
+    confirm: flags.string({description: 'set to VPN connection name to bypass confirm prompt', hidden: true}),
+  }
+
+  static args = {
+    name: Args.string({
+      required: true,
+      description: 'name or id of the VPN connection to destroy',
+    }),
+  }
+
+  public async run(): Promise<void> {
+    const {flags, args} = await this.parse(Destroy)
+    const {space, confirm} = flags
+    const {name} = args
+
+    await confirmCommand(
+      name,
+      confirm,
+      heredoc`
+        Destructive Action
+        This command will attempt to destroy the specified VPN Connection in space ${color.green(space)}
+      `,
+    )
+
+    ux.action.start(`Tearing down VPN Connection ${color.cyan(name)} in space ${color.cyan(space)}`)
+    await this.heroku.delete(`/spaces/${space}/vpn-connections/${name}`)
+    ux.action.stop()
+  }
+}
+*/

package/lib/oldCommands/spaces/vpn/info.d.ts

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

package/lib/oldCommands/spaces/vpn/info.js

@@ -0,0 +1,89 @@
+export {};
+/*
+import {Command, flags} from '@heroku-cli/command'
+import {Args} from '@oclif/core'
+import {hux} from '@heroku/heroku-cli-util'
+import * as Heroku from '@heroku-cli/schema'
+import heredoc from 'tsheredoc'
+import {displayCIDR, displayVPNStatus} from '../../../lib/spaces/format'
+
+export default class Info extends Command {
+  static topic = 'spaces';
+  static description = 'display the information for VPN';
+  static example = heredoc(`
+    $ heroku spaces:vpn:info vpn-connection-name --space my-space
+    === vpn-connection-name VPN Tunnel Info
+    Name:           vpn-connection-name
+    ID:             123456789012
+    Public IP:      35.161.69.30
+    Routable CIDRs: 172.16.0.0/16
+    Status:         failed
+    Status Message: supplied CIDR block already in use
+    === my-space Tunnel Info
+     VPN Tunnel IP Address    Status Last Changed         Details
+     ────────── ───────────── ────── ──────────────────── ─────────────
+     Tunnel 1   52.44.146.197 UP     2016-10-25T22:09:05Z status message
+     Tunnel 2   52.44.146.197 UP     2016-10-25T22:09:05Z status message
+  `)
+
+  static flags = {
+    space: flags.string({
+      char: 's',
+      description: 'space the vpn connection belongs to',
+      required: true,
+    }),
+    json: flags.boolean({description: 'output in json format'}),
+  }
+
+  static args = {
+    name: Args.string({
+      description: 'name or id of the VPN connection to get info from',
+      required: true,
+    }),
+  }
+
+  public async run(): Promise<void> {
+    const {flags, args} = await this.parse(Info)
+    const {space, json} = flags
+    const {name} = args
+    const {body: vpnConnection} = await this.heroku.get<Heroku.PrivateSpacesVpn>(`/spaces/${space}/vpn-connections/${name}`)
+    const connectionName = vpnConnection.name || name
+    this.render(connectionName, vpnConnection, json)
+  }
+
+  private displayVPNInfo(name: string, vpnConnection: Heroku.PrivateSpacesVpn) {
+    hux.styledHeader(`${name} VPN Info`)
+    hux.styledObject({
+      Name: name,
+      ID: vpnConnection.id,
+      'Public IP': vpnConnection.public_ip,
+      'Routable CIDRs': displayCIDR(vpnConnection.routable_cidrs),
+      Status: `${displayVPNStatus(vpnConnection.status)}`,
+      'Status Message': vpnConnection.status_message,
+    }, ['Name', 'ID', 'Public IP', 'Routable CIDRs', 'State', 'Status', 'Status Message'])
+    const vpnConnectionTunnels = vpnConnection.tunnels || []
+    vpnConnectionTunnels.forEach((val, i) => {
+      val.tunnel_id = 'Tunnel ' + (i + 1)
+    })
+    hux.styledHeader(`${name} VPN Tunnel Info`)
+    hux.table(vpnConnectionTunnels, {
+      tunnel_id: {header: 'VPN Tunnel'},
+      ip: {header: 'IP Address'},
+      status: {
+        header: 'Status',
+        get: row => displayVPNStatus(row.status),
+      },
+      last_status_change: {header: 'Status Last Changed'},
+      status_message: {header: 'Details'},
+    })
+  }
+
+  private render(name: string, vpnConnection: Heroku.PrivateSpacesVpn, json: boolean) {
+    if (json) {
+      hux.styledJSON(vpnConnection)
+    } else {
+      this.displayVPNInfo(name, vpnConnection)
+    }
+  }
+}
+*/

package/lib/oldCommands/spaces/vpn/update.d.ts

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

package/lib/oldCommands/spaces/vpn/update.js

@@ -0,0 +1,46 @@
+export {};
+/*
+import color from '@heroku-cli/color'
+import {Command, flags} from '@heroku-cli/command'
+import {Args, ux} from '@oclif/core'
+import {splitCsv} from '../../../lib/spaces/parsers'
+import heredoc from 'tsheredoc'
+
+export default class Update extends Command {
+  static topic = 'spaces'
+  static description = heredoc`
+    update VPN
+    Private Spaces can be connected to another private network via an IPSec VPN connection allowing dynos to connect to hosts on your private networks and vice versa.
+    The connection is established over the public Internet but all traffic is encrypted using IPSec.
+  `
+  static flags = {
+    cidrs: flags.string({char: 'c', description: 'a list of routable CIDRs separated by commas', required: true}),
+    space: flags.string({char: 's', description: 'space name', required: true}),
+  }
+
+  static example = heredoc`
+    $ heroku spaces:vpn:update vpn-connection-name --space my-space --cidrs 172.16.0.0/16,10.0.0.0/24
+    Updating VPN Connection in space my-space... done
+  `
+  static args = {
+    name: Args.string({
+      required: true,
+      description: 'name or id of the VPN connection to update',
+    }),
+  }
+
+  public async run(): Promise<void> {
+    const {flags, args} = await this.parse(Update)
+    const {space, cidrs} = flags
+    const {name} = args
+    const parsedCidrs = splitCsv(cidrs)
+
+    ux.action.start(`Updating VPN Connection in space ${color.green(space)}`)
+    await this.heroku.patch(
+      `/spaces/${space}/vpn-connections/${name}`,
+      {body: {routable_cidrs: parsedCidrs}},
+    )
+    ux.action.stop()
+  }
+}
+*/

package/lib/oldCommands/spaces/vpn/wait.d.ts

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

package/lib/oldCommands/spaces/vpn/wait.js

@@ -0,0 +1,80 @@
+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 {displayVPNConfigInfo} from '../../../lib/spaces/vpn-connections'
+import heredoc from 'tsheredoc'
+
+const wait = (ms: number) => new Promise(resolve => {
+  setTimeout(resolve, ms)
+})
+
+export default class Wait extends Command {
+    static topic = 'spaces';
+    static description = 'wait for VPN Connection to be created';
+    static examples = [heredoc`
+      $ heroku spaces:vpn:wait vpn-connection-name --space my-space
+      Waiting for VPN Connection vpn-connection-name to allocate... done
+      === my-space VPN Tunnels
+
+     VPN Tunnel Customer Gateway VPN Gateway    Pre-shared Key Routable Subnets IKE Version
+     ────────── ──────────────── ────────────── ────────────── ──────────────── ───────────
+     Tunnel 1    104.196.121.200   35.171.237.136  abcdef12345     10.0.0.0/16       1
+     Tunnel 2    104.196.121.200   52.44.7.216     fedcba54321     10.0.0.0/16       1
+    `]
+
+    static flags = {
+      space: flags.string({char: 's', description: 'space the vpn connection belongs to', required: true}),
+      json: flags.boolean({description: 'output in json format'}),
+      interval: flags.string({char: 'i', description: 'seconds to wait between poll intervals'}),
+      timeout: flags.string({char: 't', description: 'maximum number of seconds to wait'}),
+    }
+
+    static args = {
+      name: Args.string({
+        description: 'name or id of the VPN connection you are waiting on for allocation.',
+        required: true,
+      }),
+    }
+
+    public async run(): Promise<void> {
+      const {flags, args} = await this.parse(Wait)
+      const {space, json} = flags
+      const {name} = args
+      const interval = (flags.interval ? Number.parseInt(flags.interval, 10) : 10) * 1000
+      const timeout = (flags.timeout ? Number.parseInt(flags.timeout, 10) : 20 * 60) * 1000
+      const deadline = new Date(Date.now() + timeout)
+      let {body: vpnConnection} = await this.heroku.get<Heroku.PrivateSpacesVpn>(`/spaces/${space}/vpn-connections/${name}`)
+      if (vpnConnection.status === 'active') {
+        ux.log('VPN has been allocated.')
+        return
+      }
+
+      ux.action.start(`Waiting for VPN Connection ${color.green(name)} to allocate...`)
+      while (vpnConnection.status !== 'active') {
+        if (new Date() > deadline) {
+          ux.error('Timeout waiting for VPN to become allocated.', {exit: 1})
+        }
+
+        if (vpnConnection.status === 'failed') {
+          ux.error(vpnConnection.status_message || '', {exit: 1})
+        }
+
+        await wait(interval)
+        const {body: updatedVpnConnection} = await this.heroku.get<Heroku.PrivateSpacesVpn>(`/spaces/${space}/vpn-connections/${name}`)
+        vpnConnection = updatedVpnConnection
+      }
+
+      ux.action.stop()
+      const {body: newVpnConnection} = await this.heroku.get<Heroku.PrivateSpacesVpn>(`/spaces/${space}/vpn-connections/${name}`)
+      if (json) {
+        hux.styledJSON(newVpnConnection)
+      } else {
+        displayVPNConfigInfo(space, name, newVpnConnection)
+      }
+    }
+}
+*/

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

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

package/lib/oldCommands/spaces/wait.js

@@ -0,0 +1,106 @@
+export {};
+/*
+import color from '@heroku-cli/color'
+import {Command, flags} from '@heroku-cli/command'
+import {Args, ux} from '@oclif/core'
+import heredoc from 'tsheredoc'
+import Spinner from '@oclif/core/lib/cli-ux/action/spinner'
+import debug from 'debug'
+import {renderInfo} from '../../lib/spaces/spaces'
+import {Notification, notify} from '@heroku-cli/notifications'
+import {IncomingHttpHeaders} from 'node:http'
+import {SpaceNat} from '../../lib/types/fir'
+import {SpaceWithOutboundIps} from '../../lib/types/spaces'
+
+const spacesDebug = debug('spaces:wait')
+
+export default class Wait extends Command {
+  static topic = 'spaces'
+  static description = 'wait for a space to be created'
+  static flags = {
+    space: flags.string({char: 's', description: 'space to get info of'}),
+    json: flags.boolean({description: 'output in json format'}),
+    interval: flags.integer({
+      char: 'i',
+      description: 'seconds to wait between poll intervals',
+      default: 30,
+    }),
+    timeout: flags.integer({
+      char: 't',
+      description: 'maximum number of seconds to wait',
+      default: 25 * 60,
+    }),
+  }
+
+  static args = {
+    space: Args.string({hidden: true}),
+  }
+
+  public async run(): Promise<void> {
+    const {flags, args} = await this.parse(Wait)
+    const spaceName = flags.space || args.space
+    if (!spaceName) {
+      ux.error(heredoc(`
+        Error: Missing 1 required arg:
+        space
+        See more help with --help
+      `))
+    }
+
+    const interval = flags.interval * 1000
+    const timeout = flags.timeout * 1000
+    const deadline = new Date(Date.now() + timeout)
+    const action = new Spinner()
+    action.start(`Waiting for space ${color.green(spaceName as string)} to allocate`)
+
+    const headers: IncomingHttpHeaders = {
+      Accept: 'application/vnd.heroku+json; version=3.fir',
+    }
+    if (!flags.json) {
+      headers['Accept-Expansion'] = 'region'
+    }
+
+    let {body: space} = await this.heroku.get<SpaceWithOutboundIps>(`/spaces/${spaceName}`, {headers})
+    while (space.state === 'allocating') {
+      if (new Date() > deadline) {
+        throw new Error('Timeout waiting for space to become allocated.')
+      }
+
+      await this.wait(interval)
+      const {body: updatedSpace} = await this.heroku.get<SpaceWithOutboundIps>(`/spaces/${spaceName}`, {headers})
+      space = updatedSpace
+    }
+
+    try {
+      const {body: nat} = await this.heroku.get<SpaceNat>(`/spaces/${spaceName}/nat`, {headers: {Accept: 'application/vnd.heroku+json; version=3.fir'}})
+      space.outbound_ips = nat
+    } catch (error) {
+      spacesDebug(`Retrieving NAT details for the space failed with ${error}`)
+    }
+
+    action.stop()
+    renderInfo(space, flags.json)
+    this.notify(spaceName as string)
+  }
+
+  protected wait(ms: number) {
+    return new Promise(resolve => setTimeout(resolve, ms))
+  }
+
+  protected notify(spaceName: string) {
+    try {
+      const notification: Notification & {
+        sound?: boolean, message?: string, title?: string, subtitle?: string
+      } = {
+        title: spaceName,
+        subtitle: `heroku spaces:wait ${spaceName}`,
+        message: 'space was successfully created',
+        sound: true,
+      }
+      notify(notification)
+    } catch (error: any) {
+      ux.warn(error)
+    }
+  }
+}
+*/

package/lib/oldCommands/webhooks/add.d.ts

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

package/lib/oldCommands/webhooks/add.js

@@ -0,0 +1,56 @@
+export {};
+/*
+import {flags} from '@heroku-cli/command'
+import {ux} from '@oclif/core'
+import {hux} from '@heroku/heroku-cli-util'
+import Spinner from '@oclif/core/lib/cli-ux/action/spinner'
+
+import BaseCommand from '../../lib/webhooks/base'
+
+export default class WebhooksAdd extends BaseCommand {
+  static description = 'add a webhook to an app'
+
+  static examples = [
+    '$ heroku webhooks:add -i api:dyno -l notify -u https://example.com/hooks',
+  ]
+
+  static flags = {
+    app: flags.app(),
+    remote: flags.remote(),
+    pipeline: flags.pipeline({char: 'p', description: 'pipeline on which to list', hidden: true}),
+    include: flags.string({char: 'i', description: 'comma delimited event types your server will receive ', required: true}),
+    level: flags.string({char: 'l', description: 'notify does not retry, sync will retry until successful or timeout', required: true}),
+    secret: flags.string({char: 's', description: 'value to sign delivery with in Heroku-Webhook-Hmac-SHA256 header'}),
+    authorization: flags.string({char: 't', description: 'authorization header to send with webhooks'}),
+    url: flags.string({char: 'u', description: 'URL for receiver', required: true}),
+  }
+
+  async run() {
+    const {flags} = await this.parse(WebhooksAdd)
+    const {path, display} = this.webhookType(flags)
+    const action = new Spinner()
+
+    action.start(`Adding webhook to ${display}`)
+
+    const response = await this.webhooksClient.post(`${path}/webhooks`, {
+      body: {
+        include: flags.include.split(',').map(s => s.trim()),
+        level: flags.level,
+        secret: flags.secret,
+        url: flags.url,
+        authorization: flags.authorization,
+      },
+    })
+
+    const secret = response.headers && response.headers['heroku-webhook-secret'] as string
+    if (secret) {
+      hux.styledHeader('Webhooks Signing Secret')
+      this.log(secret)
+    } else {
+      ux.warn('no secret found')
+    }
+
+    action.stop()
+  }
+}
+*/

package/lib/oldCommands/webhooks/deliveries/index.d.ts

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

package/lib/oldCommands/webhooks/deliveries/index.js

@@ -0,0 +1,90 @@
+export {};
+/*
+import {flags} from '@heroku-cli/command'
+import {hux} from '@heroku/heroku-cli-util'
+
+import BaseCommand from '../../../lib/webhooks/base'
+
+export default class Deliveries extends BaseCommand {
+  static description = 'list webhook deliveries on an app'
+
+  static examples = [
+    '$ heroku webhooks:deliveries',
+  ]
+
+  static flags = {
+    app: flags.app(),
+    remote: flags.remote(),
+    status: flags.string({char: 's', description: 'filter deliveries by status'}),
+    pipeline: flags.pipeline({char: 'p', description: 'pipeline on which to list', hidden: true}),
+  }
+
+  async run() {
+    const {flags} = await this.parse(Deliveries)
+    const webhookType = this.webhookType(flags)
+    let {path} = webhookType
+    const {display} = webhookType
+    const max = 1000
+
+    path = `${path}/webhook-deliveries`
+    if (flags.status) {
+      path += `?eq[status]=${encodeURIComponent(flags.status)}`
+    }
+
+    const {body: deliveries}: { body: any[]} = await this.webhooksClient.get(path, {
+      headers: {
+        Range: `seq ..; order=desc,max=${max}`,
+      },
+      partial: true,
+    })
+
+    if (deliveries.length === 0) {
+      this.log(`${display} has no deliveries`)
+    } else {
+      const code = (w: any) => {
+        return (w.last_attempt && w.last_attempt.code && String(w.last_attempt.code)) || ''
+      }
+
+      deliveries.reverse()
+
+      if (deliveries.length === max) {
+        this.warn(`Only showing the ${max} most recent deliveries`)
+        this.warn('It is possible to filter deliveries by using the --status flag')
+      }
+
+      const printLine: typeof this.log = (...args) => this.log(...args)
+      hux.table(deliveries, {
+        id: {
+          header: 'Delivery ID',
+        },
+        created_at: {
+          header: 'Created', get: (w: any) => w.created_at,
+        },
+        status: {
+          get: (w: any) => w.status,
+        },
+        include: {
+          get: (w: any) => w.event.include,
+        },
+        level: {
+          get: (w: any) => w.webhook.level,
+        },
+        num_attempts: {
+          header: 'Attempts', get: (w: any) => String(w.num_attempts),
+        },
+        last_code: {
+          header: 'Code', get: code,
+        },
+        last_error: {
+          header: 'Error', get: (w: any) => (w.last_attempt && w.last_attempt.error_class) || '',
+        },
+        next_attempt_at: {
+          header: 'Next Attempt', get: (w: any) => w.next_attempt_at || '',
+        },
+      }, {
+        'no-header': false, printLine,
+      })
+    }
+  }
+}
+*/

package/lib/oldCommands/webhooks/deliveries/info.d.ts

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

package/lib/oldCommands/webhooks/deliveries/info.js

@@ -0,0 +1,54 @@
+export {};
+/*
+import {flags} from '@heroku-cli/command'
+import {Args} from '@oclif/core'
+import {hux} from '@heroku/heroku-cli-util'
+
+import BaseCommand from '../../../lib/webhooks/base'
+
+export default class DeliveriesInfo extends BaseCommand {
+  static description = 'info for a webhook event on an app'
+
+  static examples = [
+    '$ heroku webhooks:deliveries:info 99999999-9999-9999-9999-999999999999',
+  ]
+
+  static flags = {
+    app: flags.app(),
+    remote: flags.remote(),
+    pipeline: flags.pipeline({char: 'p', description: 'pipeline on which to list', hidden: true}),
+  }
+
+  static args = {
+    id: Args.string({required: true, description: 'ID of the webhook event'}),
+  }
+
+  async run() {
+    const {flags, args} = await this.parse(DeliveriesInfo)
+    const {path} = this.webhookType(flags)
+
+    const {body: delivery}: {body: any} = await this.webhooksClient.get(`${path}/webhook-deliveries/${args.id}`)
+
+    const {body: event}: {body: any} = await this.webhooksClient.get(`${path}/webhook-events/${delivery.event.id}`)
+
+    const obj = {
+      Created: delivery.created_at,
+      Event: delivery.event.id,
+      Webhook: delivery.webhook.id,
+      Status: delivery.status,
+      Include: delivery.event.include,
+      Level: delivery.webhook.level,
+      Attempts: delivery.num_attempts,
+      Code: delivery.last_attempt && delivery.last_attempt.code,
+      Error: delivery.last_attempt && delivery.last_attempt.error_class,
+      'Next Attempt': delivery.next_attempt_at,
+    }
+
+    hux.styledHeader(delivery.id)
+    hux.styledObject(obj)
+
+    hux.styledHeader('Event Payload')
+    hux.styledJSON(event.payload)
+  }
+}
+*/

package/lib/oldCommands/webhooks/events/index.d.ts

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