heroku 10.13.2 → 11.0.0-alpha.1

package/lib/oldCommands/spaces/trusted-ips/add.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 * as Heroku from '@heroku-cli/schema'
+import heredoc from 'tsheredoc'
+
+export default class Add extends Command {
+  static topic = 'spaces'
+  static hiddenAliases = ['trusted-ips:add']
+  static description = heredoc(`
+  Add one range to the list of trusted IP ranges
+  Uses CIDR notation.`)
+
+  static examples = [heredoc(`
+  $ heroku trusted-ips:add --space my-space 192.168.2.0/24
+    Added 192.168.0.1/24 to trusted IP ranges on my-space`)]
+
+  static flags = {
+    space: flags.string({char: 's', description: 'space to add rule to', required: true}),
+    confirm: flags.string({description: 'set to space name to bypass confirm prompt'}),
+  };
+
+  static args = {
+    source: Args.string({required: true, description: 'IP address in CIDR notation'}),
+  };
+
+  public async run(): Promise<void> {
+    const {flags, args} = await this.parse(Add)
+    const {space} = flags
+    const url = `/spaces/${space}/inbound-ruleset`
+    const {body: ruleset} = await this.heroku.get<Heroku.InboundRuleset>(url)
+    if (!this.isUniqueRule(ruleset, args.source)) {
+      throw new Error(`A rule already exists for ${args.source}.`)
+    }
+
+    ruleset.rules.push({action: 'allow', source: args.source})
+    await this.heroku.put(url, {body: ruleset})
+    ux.log(`Added ${color.cyan.bold(args.source)} to trusted IP ranges on ${color.cyan.bold(space)}`)
+    ux.warn('It may take a few moments for the changes to take effect.')
+  }
+
+  private isUniqueRule(ruleset: Heroku.InboundRuleset, source: string): ruleset is Required<Heroku.InboundRuleset> {
+    return Array.isArray(ruleset.rules) && !ruleset.rules.some(rs => rs.source === source)
+  }
+}
+*/

package/lib/oldCommands/spaces/trusted-ips/index.d.ts

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

package/lib/oldCommands/spaces/trusted-ips/index.js

@@ -0,0 +1,57 @@
+export {};
+/*
+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 heredoc from 'tsheredoc'
+
+export default class Index extends Command {
+  static topic = 'spaces'
+  static hiddenAliases = ['trusted-ips']
+  static description = heredoc(`
+  list trusted IP ranges for a space
+  Trusted IP ranges are only available on Private Spaces.
+
+  The space name is a required parameter. Newly created spaces will have 0.0.0.0/0 set by default
+  allowing all traffic to applications in the space. More than one CIDR block can be provided at
+  a time to the commands listed below. For example 1.2.3.4/20 and 5.6.7.8/20 can be added with:
+  `)
+
+  static flags = {
+    space: flags.string({char: 's', description: 'space to get inbound rules 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(Index)
+    const space = flags.space || args.space
+    if (!space) {
+      throw new Error('Space name required.\nUSAGE: heroku trusted-ips my-space')
+    }
+
+    const {body: rules} = await this.heroku.get<Required<Heroku.InboundRuleset>>(`/spaces/${space}/inbound-ruleset`)
+
+    if (flags.json) {
+      ux.log(JSON.stringify(rules, null, 2))
+    } else {
+      this.displayRules(space, rules)
+    }
+  }
+
+  private displayRules(space: string, ruleset: Required<Heroku.InboundRuleset>) {
+    if (ruleset.rules.length > 0) {
+      hux.styledHeader('Trusted IP Ranges')
+      for (const rule of ruleset.rules) {
+        ux.log(rule.source)
+      }
+    } else {
+      hux.styledHeader(`${space} has no trusted IP ranges. All inbound web requests to dynos are blocked.`)
+    }
+  }
+}
+*/

package/lib/oldCommands/spaces/trusted-ips/remove.d.ts

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

package/lib/oldCommands/spaces/trusted-ips/remove.js

@@ -0,0 +1,50 @@
+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 heredoc from 'tsheredoc'
+
+export default class Remove extends Command {
+  static topic = 'spaces'
+  static hiddenAliases = ['trusted-ips:remove']
+  static description = heredoc(`
+  Remove a range from the list of trusted IP ranges
+  Uses CIDR notation.`)
+
+  static examples = [heredoc(`
+  $ heroku trusted-ips:remove --space my-space 192.168.2.0/24
+      Removed 192.168.2.0/24 from trusted IP ranges on my-space
+        `)]
+
+  static flags = {
+    space: flags.string({required: true, char: 's', description: 'space to remove rule from'}),
+    confirm: flags.string({description: 'set to space name to bypass confirm prompt'}),
+  }
+
+  static args = {
+    source: Args.string({required: true, description: 'IP address in CIDR notation'}),
+  }
+
+  public async run(): Promise<void> {
+    const {flags, args} = await this.parse(Remove)
+    const space = flags.space
+    const url = `/spaces/${space}/inbound-ruleset`
+    const {body: rules} = await this.heroku.get<Heroku.InboundRuleset>(url)
+    if (rules.rules?.length === 0) {
+      throw new Error('No IP ranges are configured. Nothing to do.')
+    }
+
+    const originalLength = rules.rules?.length
+    rules.rules = rules.rules?.filter(r => r.source !== args.source)
+    if (rules.rules?.length === originalLength) {
+      throw new Error(`No IP range matching ${args.source} was found.`)
+    }
+
+    await this.heroku.put(url, {body: rules})
+    ux.log(`Removed ${color.cyan.bold(args.source)} from trusted IP ranges on ${color.cyan.bold(space)}`)
+    ux.warn('It may take a few moments for the changes to take effect.')
+  }
+}
+*/

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

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

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

@@ -0,0 +1,61 @@
+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 {displayVPNConfigInfo} from '../../../lib/spaces/vpn-connections'
+import heredoc from 'tsheredoc'
+
+export default class Config extends Command {
+  static topic = 'spaces'
+  static description = heredoc(`
+    display the configuration information for VPN
+
+    You will use the information provided by this command to establish a Private Space VPN Connection.
+
+    - You must configure your VPN Gateway to use both Tunnels provided by Heroku
+    - The VPN Gateway values are the IP addresses of the Private Space Tunnels
+    - The Customer Gateway value is the Public IP of your VPN Gateway
+    - The VPN Gateway must use the IKE Version shown and the Pre-shared Keys as the authentication method
+  `)
+
+  static example = heredoc(`
+    $ heroku spaces:vpn:config vpn-connection-name --space my-space
+    === vpn-connection-name 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({
+      required: true,
+      char: 's',
+      description: 'space the VPN connection belongs to',
+    }),
+    json: flags.boolean({description: 'output in json format'}),
+  }
+
+  static args = {
+    name: Args.string({
+      required: true,
+      description: 'name or id of the VPN connection to retrieve config from',
+    }),
+  }
+
+  public async run(): Promise<void> {
+    const {flags, args} = await this.parse(Config)
+    const {space, json} = flags
+    const {name} = args
+
+    const {body: vpnConnection} = await this.heroku.get<Heroku.PrivateSpacesVpn>(`/spaces/${space}/vpn-connections/${name}`)
+    if (json) {
+      hux.styledJSON(vpnConnection)
+    } else {
+      displayVPNConfigInfo(space, name, vpnConnection)
+    }
+  }
+}
+*/

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

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

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

@@ -0,0 +1,54 @@
+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 {splitCsv} from '../../../lib/spaces/parsers'
+
+export default class Connect extends Command {
+  static topic = 'spaces'
+  static description = heredoc`
+    create 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 examples = [heredoc`
+    $ heroku spaces:vpn:connect vpn-connection-name --ip 35.161.69.30 --cidrs 172.16.0.0/16,10.0.0.0/24 --space my-space
+    Creating VPN Connection in space my-space... done
+    ▸    Use spaces:vpn:wait to track allocation.
+  `]
+
+  static flags = {
+    ip: flags.string({char: 'i', description: 'public IP of customer gateway', required: true}),
+    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 args = {
+    name: Args.string({
+      required: true,
+      description: 'name or id of the VPN connection to create',
+    }),
+  }
+
+  public async run(): Promise<void> {
+    const {flags, args} = await this.parse(Connect)
+    const {space, cidrs, ip} = flags
+    const {name} = args
+    const parsed_cidrs = splitCsv(cidrs)
+
+    ux.action.start(`Creating VPN Connection in space ${color.green(space)}`)
+    await this.heroku.post(`/spaces/${space}/vpn-connections`, {
+      body: {
+        name,
+        public_ip: ip,
+        routable_cidrs: parsed_cidrs,
+      },
+    })
+    ux.action.stop()
+
+    ux.warn(`Use ${color.cmd('heroku spaces:vpn:wait')} to track allocation.`)
+  }
+}
+*/

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

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

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