heroku 10.13.2 → 11.0.0-alpha.2

package/lib/oldCommands/spaces/index.js

@@ -0,0 +1,74 @@
+export {};
+/*
+import color from '@heroku-cli/color'
+import {Command, flags as Flags} from '@heroku-cli/command'
+import {ux} from '@oclif/core'
+import {hux} from '@heroku/heroku-cli-util'
+import {Space} from '../../lib/types/fir'
+import {getGeneration} from '../../lib/apps/generation'
+
+type SpaceArray = Array<Required<Space>>
+
+export default class Index extends Command {
+  static topic = 'spaces'
+  static description = 'list available spaces'
+  static flags = {
+    json: Flags.boolean({description: 'output in json format'}),
+    team: Flags.team(),
+  };
+
+  public async run(): Promise<void> {
+    const {flags} = await this.parse(Index)
+    const {team, json} = flags
+    let {body: spaces} = await this.heroku.get<SpaceArray>('/spaces', {
+      headers: {
+        Accept: 'application/vnd.heroku+json; version=3.sdk',
+      },
+    })
+    if (team) {
+      spaces = spaces.filter(s => s.team.name === team)
+    }
+
+    spaces = this.sortByName(spaces)
+
+    if (json)
+      this.displayJSON(spaces)
+    else if (spaces.length === 0) {
+      if (team)
+        ux.error(`No spaces in ${color.cyan(team)}.`)
+      else
+        ux.error('You do not have access to any spaces.')
+    } else {
+      this.display(spaces)
+    }
+  }
+
+  protected sortByName(spaces: SpaceArray) {
+    spaces.sort((a, b) => {
+      return a.name === b.name ? 0 : (a.name < b.name ? -1 : 1)
+    })
+    return spaces
+  }
+
+  protected displayJSON(spaces: SpaceArray) {
+    ux.log(JSON.stringify(spaces, null, 2))
+  }
+
+  protected display(spaces: SpaceArray) {
+    hux.table(
+      spaces,
+      {
+        Name: {get: space => space.name},
+        Team: {get: space => space.team.name},
+        Region: {get: space => space.region.name},
+        State: {get: space => space.state},
+        Generation: {get: space => getGeneration(space)},
+        createdAt: {
+          header: 'Created At',
+          get: space => space.created_at,
+        },
+      },
+    )
+  }
+}
+*/

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

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

package/lib/oldCommands/spaces/info.js

@@ -0,0 +1,59 @@
+export {};
+/*
+import {Command, flags} from '@heroku-cli/command'
+import {Args, ux} from '@oclif/core'
+import heredoc from 'tsheredoc'
+import {renderInfo} from '../../lib/spaces/spaces'
+import debug from 'debug'
+import {IncomingHttpHeaders} from 'node:http'
+import {Space, SpaceNat} from '../../lib/types/fir'
+import {SpaceWithOutboundIps} from '../../lib/types/spaces'
+
+const spacesDebug = debug('spaces:info')
+
+export default class Info extends Command {
+  static topic = 'spaces'
+  static description = 'show info about a space'
+  static example = '$ heroku spaces:info my-space'
+
+  static flags = {
+    space: flags.string({char: 's', description: 'space to get info of'}),
+    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(Info)
+    const spaceName = flags.space || args.space
+    if (!spaceName) {
+      ux.error(heredoc(`
+        Error: Missing 1 required arg:
+        space
+        See more help with --help
+      `))
+    }
+
+    const headers: IncomingHttpHeaders = {
+      Accept: 'application/vnd.heroku+json; version=3.fir',
+    }
+    if (!flags.json) {
+      headers['Accept-Expansion'] = 'region'
+    }
+
+    const {body: space} = await this.heroku.get<SpaceWithOutboundIps>(`/spaces/${spaceName}`, {headers})
+    if (space.state === 'allocated') {
+      try {
+        const {body: outbound_ips} = await this.heroku.get<SpaceNat>(`/spaces/${spaceName}/nat`, {headers: {Accept: 'application/vnd.heroku+json; version=3.fir'}})
+        space.outbound_ips = outbound_ips
+      } catch (error) {
+        spacesDebug(`Retrieving NAT details for the space failed with ${error}`)
+      }
+    }
+
+    renderInfo(space, flags.json)
+  }
+}
+*/

package/lib/oldCommands/spaces/peerings/accept.d.ts

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

package/lib/oldCommands/spaces/peerings/accept.js

@@ -0,0 +1,41 @@
+export {};
+/*
+import color from '@heroku-cli/color'
+import {Command, flags} from '@heroku-cli/command'
+import {Args, ux} from '@oclif/core'
+import heredoc from 'tsheredoc'
+
+export default class Accept extends Command {
+  static topic = 'spaces'
+  static description = 'accepts a pending peering request for a private space'
+  static examples = [heredoc(`
+  $ heroku spaces:peerings:accept pcx-4bd27022 --space example-space
+      Accepting and configuring peering connection pcx-4bd27022
+  `)]
+
+  static flags = {
+    pcxid: flags.string({char: 'p', description: 'PCX ID of a pending peering'}),
+    space: flags.string({char: 's', description: 'space to get peering info from'}),
+  }
+
+  static args = {
+    pcxid: Args.string({hidden: true}),
+    space: Args.string({hidden: true}),
+  }
+
+  public async run(): Promise<void> {
+    const {flags, args} = await this.parse(Accept)
+    const space = flags.space || args.space
+    if (!space) {
+      throw new Error('Space name required.\nUSAGE: heroku spaces:peerings:accept pcx-12345678 --space my-space')
+    }
+
+    const pcxID = flags.pcxid || args.pcxid
+    await this.heroku.post(`/spaces/${space}/peerings`, {
+      body: {pcx_id: pcxID},
+      headers: {Accept: 'application/vnd.heroku+json; version=3.dogwood'},
+    })
+    ux.log(`Accepting and configuring peering connection ${color.cyan.bold(pcxID)}`)
+  }
+}
+*/

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

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

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

@@ -0,0 +1,51 @@
+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 confirmCommand from '../../../lib/confirmCommand'
+
+export default class Destroy extends Command {
+  static topic = 'spaces'
+  static description = 'destroys an active peering connection in a private space'
+  static flags = {
+    pcxid: flags.string({char: 'p', description: 'PCX ID of a pending peering'}),
+    space: flags.string({
+      char: 's',
+      description: 'space to get peering info from',
+      required: true,
+    }),
+    confirm: flags.string({description: 'set to PCX ID to bypass confirm prompt'}),
+  };
+
+  static args = {
+    pcxid: Args.string({hidden: true}),
+  }
+
+  static example = heredoc(`
+    $ heroku spaces:peerings:destroy pcx-4bd27022 --confirm pcx-4bd27022 --space example-space
+    Tearing down peering connection pcx-4bd27022... done
+  `)
+
+  public async run(): Promise<void> {
+    const {flags, args} = await this.parse(Destroy)
+
+    const pcxID = flags.pcxid || args.pcxid
+    if (!pcxID) {
+      ux.error(heredoc`
+        pcxid required.
+        USAGE: heroku spaces:peering:destroy pcx-4bd27022
+      `)
+    }
+
+    await confirmCommand(pcxID as string, flags.confirm, heredoc(`
+      Destructive Action
+      This command will attempt to destroy the peering connection ${color.bold.red(pcxID)}
+    `))
+    ux.action.start(`Tearing down peering connection ${color.cyan.bold(pcxID)}`)
+    await this.heroku.delete(`/spaces/${flags.space}/peerings/${pcxID}`)
+    ux.action.stop()
+  }
+}
+*/

package/lib/oldCommands/spaces/peerings/index.d.ts

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

package/lib/oldCommands/spaces/peerings/index.js

@@ -0,0 +1,39 @@
+export {};
+/*
+import {Command, flags} from '@heroku-cli/command'
+import {Args, ux} from '@oclif/core'
+import * as Heroku from '@heroku-cli/schema'
+import {displayPeerings, displayPeeringsAsJSON} from '../../../lib/spaces/peering'
+import heredoc from 'tsheredoc'
+
+export default class Index extends Command {
+    static topic = 'spaces';
+    static description = 'list peering connections for a space';
+    static flags = {
+      space: flags.string({char: 's', description: 'space to get peer list 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 spaceName = flags.space || args.space
+      if (!spaceName) {
+        ux.error(heredoc`
+          space required.
+          USAGE: heroku spaces:peerings my-space
+        `)
+      }
+
+      const {body: peerings} = await this.heroku.get<Heroku.Peering[]>(`/spaces/${spaceName}/peerings`)
+
+      if (flags.json)
+        displayPeeringsAsJSON(peerings)
+      else
+        displayPeerings(spaceName as string, peerings)
+    }
+}
+*/

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

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

package/lib/{commands → oldCommands}/spaces/peerings/info.js

@@ -1,31 +1,15 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const command_1 = require("@heroku-cli/command");
-const core_1 = require("@oclif/core");
-const tsheredoc_1 = require("tsheredoc");
-const peering_1 = require("../../../lib/spaces/peering");
-class Info extends command_1.Command {
-    async run() {
-        const { flags, args } = await this.parse(Info);
-        const spaceName = flags.space || args.space;
-        if (!spaceName) {
-            core_1.ux.error((0, tsheredoc_1.default)(`
-        Error: Missing 1 required arg:
-        space
-        See more help with --help
-      `));
-        }
-        const { body: pInfo } = await this.heroku.get(`/spaces/${spaceName}/peering-info`);
-        if (flags.json)
-            core_1.ux.log(JSON.stringify(pInfo, null, 2));
-        else
-            (0, peering_1.displayPeeringInfo)(spaceName, pInfo);
-    }
-}
-exports.default = Info;
-Info.topic = 'spaces';
-Info.hiddenAliases = ['spaces:peering:info'];
-Info.description = (0, tsheredoc_1.default)(`
+export {};
+/*
+import {Command, flags} from '@heroku-cli/command'
+import {Args, ux} from '@oclif/core'
+import * as Heroku from '@heroku-cli/schema'
+import heredoc from 'tsheredoc'
+import {displayPeeringInfo} from '../../../lib/spaces/peering'
+
+export default class Info extends Command {
+  static topic = 'spaces'
+  static hiddenAliases = ['spaces:peering:info']
+  static description = heredoc(`
     display the information necessary to initiate a peering connection
 
     You will use the information provided by this command to establish a peering connection request from your AWS VPC to your private space.
@@ -38,12 +22,14 @@ Info.description = (0, tsheredoc_1.default)(`
 
     Once you've established the peering connection request, you can use the spaces:peerings:accept command to accept and
     configure the peering connection for the space.
-  `);
-Info.flags = {
-    space: command_1.flags.string({ char: 's', description: 'space to get peering info from' }),
-    json: command_1.flags.boolean({ description: 'output in json format' }),
-};
-Info.examples = [(0, tsheredoc_1.default)(`
+  `)
+
+  static flags = {
+    space: flags.string({char: 's', description: 'space to get peering info from'}),
+    json: flags.boolean({description: 'output in json format'}),
+  }
+
+  static examples = [heredoc(`
     $ heroku spaces:peering:info example-space
     === example-space  Peering Info
 
@@ -53,7 +39,28 @@ Info.examples = [(0, tsheredoc_1.default)(`
     AWS VPC CIDR:      10.0.0.0/16
     Space CIDRs:       10.0.128.0/20, 10.0.144.0/20
     Unavailable CIDRs: 10.1.0.0/16
-  `)];
-Info.args = {
-    space: core_1.Args.string({ hidden: true }),
-};
+  `)]
+
+  static args = {
+    space: Args.string({hidden: true}),
+  }
+
+  public async run(): Promise<void> {
+    const {flags, args} = await this.parse(Info)
+    const spaceName = flags.space || args.space
+    if (!spaceName) {
+      ux.error(heredoc(`
+        Error: Missing 1 required arg:
+        space
+        See more help with --help
+      `))
+    }
+
+    const {body: pInfo} = await this.heroku.get<Heroku.PeeringInfo>(`/spaces/${spaceName}/peering-info`)
+    if (flags.json)
+      ux.log(JSON.stringify(pInfo, null, 2))
+    else
+      displayPeeringInfo(spaceName as string, pInfo)
+  }
+}
+*/

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

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

package/lib/oldCommands/spaces/ps.js

@@ -0,0 +1,97 @@
+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 {ago} from '../../lib/time'
+
+const getProcessNum = (s: string) => Number.parseInt(s.split('.', 2)[1], 10)
+
+type SpaceDynosInfo = {
+  app_name: string,
+  dynos: Required<Heroku.Dyno>[]
+}
+export default class Ps extends Command {
+  static topic = 'spaces';
+  static description = 'list dynos for a space';
+  static flags = {
+    space: flags.string({char: 's', description: 'space to get dynos of'}),
+    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(Ps)
+    const spaceName = flags.space || args.space
+    if (!spaceName) {
+      throw new Error('Space name required.\nUSAGE: heroku spaces:ps my-space')
+    }
+
+    const [{body: spaceDynos}, {body: space}] = await Promise.all([
+      this.heroku.get<SpaceDynosInfo[]>(`/spaces/${spaceName}/dynos`),
+      this.heroku.get<Heroku.Space>(`/spaces/${spaceName}`),
+    ])
+
+    if (space.shield) {
+      spaceDynos.forEach(spaceDyno => {
+        spaceDyno.dynos.forEach(d => {
+          if (d.size?.startsWith('Private')) {
+            d.size = d.size.replace('Private-', 'Shield-')
+          }
+        })
+      })
+    }
+
+    if (flags.json) {
+      hux.styledJSON(spaceDynos)
+    } else {
+      this.render(spaceDynos)
+    }
+  }
+
+  private render(spaceDynos?: SpaceDynosInfo[]) {
+    spaceDynos?.forEach(spaceDyno => {
+      this.printDynos(spaceDyno.app_name, spaceDyno.dynos)
+    })
+  }
+
+  private printDynos(appName: string, dynos: Required<Heroku.Dyno>[]) {
+    const dynosByCommand = new Map<string, string[]>()
+    for (const dyno of dynos) {
+      const since = ago(new Date(dyno.updated_at))
+      const size = dyno.size ?? '1X'
+      let key = ''
+      let item = ''
+      if (dyno.type === 'run') {
+        key = 'run: one-off processes'
+        item = `${dyno.name} (${size}): ${dyno.state} ${since}: ${dyno.command}`
+      } else {
+        key = `${color.green(dyno.type)} (${color.cyan(size)}): ${dyno.command}`
+        const state = dyno.state === 'up' ? color.green(dyno.state) : color.yellow(dyno.state)
+        item = `${dyno.name}: ${color.green(state)} ${color.dim(since)}`
+      }
+
+      if (!dynosByCommand.has(key)) {
+        dynosByCommand.set(key, [])
+      }
+
+      dynosByCommand.get(key)?.push(item)
+    }
+
+    for (const [key, dynos] of dynosByCommand) {
+      hux.styledHeader(`${appName} ${key} (${color.yellow(dynos.length)})`)
+      dynos.sort((a, b) => getProcessNum(a) - getProcessNum(b))
+      for (const dyno of dynos) {
+        ux.log(dyno)
+      }
+
+      ux.log()
+    }
+  }
+}
+*/

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

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

package/lib/oldCommands/spaces/rename.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 heredoc from 'tsheredoc'
+
+export default class Rename extends Command {
+  static topic = 'spaces';
+  static description = 'renames a space';
+  static example = heredoc(`
+    $ heroku spaces:rename --from old-space-name --to new-space-name
+    Renaming space old-space-name to new-space-name... done
+  `)
+
+  static flags = {
+    from: flags.string({required: true, description: 'current name of space'}),
+    to: flags.string({required: true, description: 'desired name of space'}),
+  };
+
+  public async run(): Promise<void> {
+    const {flags} = await this.parse(Rename)
+    const {to, from} = flags
+    ux.action.start(`Renaming space from ${color.cyan(from)} to ${color.green(to)}`)
+    await this.heroku.patch(`/spaces/${from}`, {body: {name: to}})
+    ux.action.stop()
+  }
+}
+*/

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

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

package/lib/oldCommands/spaces/topology.js

@@ -0,0 +1,95 @@
+export {};
+/*
+export default class Topology extends Command {
+  static topic = 'spaces';
+  static description = 'show space topology';
+  static flags = {
+    space: flags.string({char: 's', description: 'space to get topology of'}),
+    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(Topology)
+    const spaceName = flags.space || args.space
+    if (!spaceName) {
+      ux.error(heredoc(`
+        Error: Missing 1 required arg:
+        space
+        See more help with --help
+      `))
+    }
+
+    const {body: topology} = await this.heroku.get<SpaceTopology>(`/spaces/${spaceName}/topology`)
+    let appInfo: Heroku.App[] = []
+    if (topology.apps) {
+      appInfo = await Promise.all(topology.apps.map(async topologyApp => {
+        const {body: app} = await this.heroku.get<Heroku.App>(`/apps/${topologyApp.id}`)
+        return app
+      }))
+    }
+
+    this.render(topology, appInfo, flags.json)
+  }
+
+  protected render(topology: SpaceTopology, appInfo: Heroku.App[], json: boolean) {
+    if (json) {
+      hux.styledJSON(topology)
+    } else if (topology.apps) {
+      topology.apps.forEach(app => {
+        const formations: string[] = []
+        const dynos: string[] = []
+        if (app.formations) {
+          app.formations.forEach(formation => {
+            formations.push(formation.process_type)
+            if (formation.dynos) {
+              formation.dynos.forEach(dyno => {
+                const dynoS = [`${formation.process_type}.${dyno.number}`, dyno.private_ip, dyno.hostname].filter(Boolean)
+                dynos.push(dynoS.join(' - '))
+              })
+            }
+          })
+        }
+
+        const domains = app.domains.sort()
+        formations.sort()
+        dynos.sort((a, b) => {
+          const apt = this.getProcessType(a)
+          const bpt = this.getProcessType(b)
+          if (apt > bpt) {
+            return 1
+          }
+
+          if (apt < bpt) {
+            return -1
+          }
+
+          return this.getProcessNum(a) - this.getProcessNum(b)
+        })
+        const info = appInfo.find(info => info.id === app.id)
+        let header = info?.name
+        if (formations.length > 0) {
+          header += ` (${color.cyan(formations.join(', '))})`
+        }
+
+        hux.styledHeader(header || '')
+        hux.styledObject({
+          Domains: domains, Dynos: dynos,
+        }, ['Domains', 'Dynos'])
+        ux.log()
+      })
+    }
+  }
+
+  protected getProcessType(s: string) {
+    return s.split('-', 2)[0].split('.', 2)[0]
+  }
+
+  protected getProcessNum(s: string) {
+    return Number.parseInt(s.split('-', 2)[0].split('.', 2)[1], 10)
+  }
+}
+*/

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

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

package/lib/oldCommands/spaces/transfer.js

@@ -0,0 +1,37 @@
+export {};
+/*
+import color from '@heroku-cli/color'
+import {Command, flags} from '@heroku-cli/command'
+import {ux} from '@oclif/core'
+import heredoc from 'tsheredoc'
+
+export default class Transfer extends Command {
+  static topic = 'spaces'
+  static description = 'transfer a space to another team'
+  static examples = [heredoc(`
+  $ heroku spaces:transfer --space=space-name --team=team-name
+  Transferring space-name to team-name... done
+  `)]
+
+  static flags = {
+    space: flags.string({required: true, char: 's', description: 'name of space'}),
+    team: flags.string({required: true, char: 't', description: 'desired owner of space'}),
+  }
+
+  public async run(): Promise<void> {
+    const {flags} = await this.parse(Transfer)
+    const space = flags.space
+    const team = flags.team
+
+    try {
+      ux.action.start(`Transferring space ${color.yellow(space)} to team ${color.green(team)}`)
+      await this.heroku.post(`/spaces/${space}/transfer`, {body: {new_owner: team}})
+    } catch (error) {
+      const {body: {message}} = error as {body: {message: string}}
+      ux.error(message)
+    } finally {
+      ux.action.stop()
+    }
+  }
+}
+*/

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

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