heroku 9.0.0-alpha.1 → 9.0.0-alpha.2

package/lib/commands/spaces/outbound-rules/index.js

@@ -0,0 +1,49 @@
+"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 outbound_rules_1 = require("../../../lib/spaces/outbound-rules");
+const completions_1 = require("@heroku-cli/command/lib/completions");
+class Index extends command_1.Command {
+    async run() {
+        const { flags, args } = await this.parse(Index);
+        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: ruleset } = await this.heroku.get(`/spaces/${spaceName}/outbound-ruleset`, {
+            headers: { Accept: 'application/vnd.heroku+json; version=3.dogwood' },
+        });
+        if (flags.json)
+            (0, outbound_rules_1.displayRulesAsJSON)(ruleset);
+        else
+            (0, outbound_rules_1.displayRules)(spaceName, ruleset);
+    }
+}
+exports.default = Index;
+Index.topic = 'spaces';
+Index.aliases = ['outbound-rules'];
+Index.description = (0, tsheredoc_1.default)(`
+    list Outbound Rules for a space
+    Outbound Rules are only available on Private Spaces.
+
+    Newly created spaces will have an "Allow All" rule set by default
+    allowing all egress dyno traffic outside of the space.  You can
+    remove this default rule to completely stop your private dynos from
+    talking to the world.
+
+    You can add specific rules that only allow your dyno to communicate with trusted hosts.
+  `);
+Index.hidden = true;
+Index.flags = {
+    space: command_1.flags.string({ char: 's', description: 'space to get outbound rules from', completion: completions_1.SpaceCompletion }),
+    json: command_1.flags.boolean({ description: 'output in json format' }),
+};
+Index.args = {
+    space: core_1.Args.string({ hidden: true }),
+};

package/lib/commands/spaces/outbound-rules/remove.d.ts

@@ -0,0 +1,17 @@
+import { Command } from '@heroku-cli/command';
+export default class Remove extends Command {
+    static topic: string;
+    static aliases: string[];
+    static description: string;
+    static examples: string[];
+    static hidden: boolean;
+    static flags: {
+        space: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        confirm: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+    };
+    static args: {
+        ruleNumber: import("@oclif/core/lib/interfaces/parser").Arg<string, Record<string, unknown>>;
+    };
+    private clientOptions;
+    run(): Promise<void>;
+}

package/lib/commands/spaces/outbound-rules/remove.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const color_1 = require("@heroku-cli/color");
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const tsheredoc_1 = require("tsheredoc");
+const confirmCommand_1 = require("../../../lib/confirmCommand");
+class Remove extends command_1.Command {
+    constructor() {
+        super(...arguments);
+        this.clientOptions = {
+            headers: { Accept: 'application/vnd.heroku+json; version=3.dogwood' },
+        };
+    }
+    async run() {
+        var _a;
+        const { flags, args } = await this.parse(Remove);
+        const space = flags.space;
+        if (!space)
+            throw new Error('Space name required.');
+        const { body: ruleset } = await this.heroku.get(`/spaces/${space}/outbound-ruleset`, this.clientOptions);
+        if (!((_a = ruleset.rules) === null || _a === void 0 ? void 0 : _a.length)) {
+            throw new Error('No Outbound Rules configured. Nothing to do.');
+        }
+        const deleted = ruleset.rules.splice(Number.parseInt(args.ruleNumber, 10) - 1, 1)[0];
+        await (0, confirmCommand_1.default)(space, flags.confirm, (0, tsheredoc_1.default)(`
+    Destructive Action
+    This will remove:
+    Destination: ${deleted.target}, From Port: ${deleted.from_port}, To Port: ${deleted.to_port}, Protocol ${deleted.protocol}
+    from the Outbound Rules on ${color_1.default.cyan.bold(space)}
+    `));
+        const opts = Object.assign(Object.assign({}, this.clientOptions), { body: ruleset });
+        await this.heroku.put(`/spaces/${space}/outbound-ruleset`, opts);
+        core_1.ux.log(`Removed Rule ${color_1.default.cyan.bold(args.ruleNumber)} from Outbound Rules on ${color_1.default.cyan.bold(space)}`);
+        core_1.ux.warn('It may take a few moments for the changes to take effect.');
+    }
+}
+exports.default = Remove;
+Remove.topic = 'spaces';
+Remove.aliases = ['outbound-rules:remove'];
+Remove.description = 'Remove a Rules from the list of Outbound Rules';
+Remove.examples = [(0, tsheredoc_1.default)(`
+  $ heroku outbound-rules:remove --space my-space 4
+      Removed 192.168.2.0/24 from trusted IP ranges on my-space
+  `)];
+Remove.hidden = true;
+Remove.flags = {
+    space: command_1.flags.string({ optional: false, description: 'space to remove rule from' }),
+    confirm: command_1.flags.string({ description: 'set to space name to bypass confirm prompt' }),
+};
+Remove.args = {
+    ruleNumber: core_1.Args.string({ required: true }),
+};

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

@@ -0,0 +1,15 @@
+import { Command } from '@heroku-cli/command';
+export default class Accept extends Command {
+    static topic: string;
+    static description: string;
+    static examples: string[];
+    static flags: {
+        pcxid: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        space: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+    };
+    static args: {
+        pcxid: import("@oclif/core/lib/interfaces/parser").Arg<string | undefined, Record<string, unknown>>;
+        space: import("@oclif/core/lib/interfaces/parser").Arg<string | undefined, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}

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

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const color_1 = require("@heroku-cli/color");
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const tsheredoc_1 = require("tsheredoc");
+class Accept extends command_1.Command {
+    async run() {
+        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' },
+        });
+        core_1.ux.log(`Accepting and configuring peering connection ${color_1.default.cyan.bold(pcxID)}`);
+    }
+}
+exports.default = Accept;
+Accept.topic = 'spaces';
+Accept.description = 'accepts a pending peering request for a private space';
+Accept.examples = [(0, tsheredoc_1.default)(`
+  $ heroku spaces:peerings:accept pcx-4bd27022 --space example-space
+      Accepting and configuring peering connection pcx-4bd27022
+  `)];
+Accept.flags = {
+    pcxid: command_1.flags.string({ char: 'p', description: 'PCX ID of a pending peering' }),
+    space: command_1.flags.string({ char: 's', description: 'space to get peering info from' }),
+};
+Accept.args = {
+    pcxid: core_1.Args.string({ hidden: true }),
+    space: core_1.Args.string({ hidden: true }),
+};

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

@@ -0,0 +1,15 @@
+import { Command } from '@heroku-cli/command';
+export default class Destroy extends Command {
+    static topic: string;
+    static description: string;
+    static flags: {
+        pcxid: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        space: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        confirm: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+    };
+    static args: {
+        pcxid: import("@oclif/core/lib/interfaces/parser").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static example: string;
+    run(): Promise<void>;
+}

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

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const color_1 = require("@heroku-cli/color");
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const tsheredoc_1 = require("tsheredoc");
+const confirmCommand_1 = require("../../../lib/confirmCommand");
+class Destroy extends command_1.Command {
+    async run() {
+        const { flags, args } = await this.parse(Destroy);
+        const pcxID = flags.pcxid || args.pcxid;
+        if (!pcxID) {
+            core_1.ux.error((0, tsheredoc_1.default) `
+        pcxid required.
+        USAGE: heroku spaces:peering:destroy pcx-4bd27022
+      `);
+        }
+        await (0, confirmCommand_1.default)(pcxID, flags.confirm, (0, tsheredoc_1.default)(`
+      Destructive Action
+      This command will attempt to destroy the peering connection ${color_1.default.bold.red(pcxID)}
+    `));
+        core_1.ux.action.start(`Tearing down peering connection ${color_1.default.cyan.bold(pcxID)}`);
+        await this.heroku.delete(`/spaces/${flags.space}/peerings/${pcxID}`);
+        core_1.ux.action.stop();
+    }
+}
+exports.default = Destroy;
+Destroy.topic = 'spaces';
+Destroy.description = 'destroys an active peering connection in a private space';
+Destroy.flags = {
+    pcxid: command_1.flags.string({ char: 'p', description: 'PCX ID of a pending peering' }),
+    space: command_1.flags.string({
+        char: 's',
+        description: 'space to get peering info from',
+        required: true,
+    }),
+    confirm: command_1.flags.string({ description: 'set to PCX ID to bypass confirm prompt' }),
+};
+Destroy.args = {
+    pcxid: core_1.Args.string({ hidden: true }),
+};
+Destroy.example = (0, tsheredoc_1.default)(`
+    $ heroku spaces:peerings:destroy pcx-4bd27022 --confirm pcx-4bd27022 --space example-space
+    Tearing down peering connection pcx-4bd27022... done
+  `);

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

@@ -0,0 +1,13 @@
+import { Command } from '@heroku-cli/command';
+export default class Index extends Command {
+    static topic: string;
+    static description: string;
+    static flags: {
+        space: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    static args: {
+        space: import("@oclif/core/lib/interfaces/parser").Arg<string | undefined, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const peering_1 = require("../../../lib/spaces/peering");
+const tsheredoc_1 = require("tsheredoc");
+class Index extends command_1.Command {
+    async run() {
+        const { flags, args } = await this.parse(Index);
+        const spaceName = flags.space || args.space;
+        if (!spaceName) {
+            core_1.ux.error((0, tsheredoc_1.default) `
+          space required.
+          USAGE: heroku spaces:peerings my-space
+        `);
+        }
+        const { body: peerings } = await this.heroku.get(`/spaces/${spaceName}/peerings`);
+        if (flags.json)
+            (0, peering_1.displayPeeringsAsJSON)(peerings);
+        else
+            (0, peering_1.displayPeerings)(spaceName, peerings);
+    }
+}
+exports.default = Index;
+Index.topic = 'spaces';
+Index.description = 'list peering connections for a space';
+Index.flags = {
+    space: command_1.flags.string({ char: 's', description: 'space to get peer list from' }),
+    json: command_1.flags.boolean({ description: 'output in json format' }),
+};
+Index.args = {
+    space: core_1.Args.string({ hidden: true }),
+};

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

@@ -0,0 +1,15 @@
+import { Command } from '@heroku-cli/command';
+export default class Info extends Command {
+    static topic: string;
+    static hiddenAliases: string[];
+    static description: string;
+    static flags: {
+        space: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    static examples: string[];
+    static args: {
+        space: import("@oclif/core/lib/interfaces/parser").Arg<string | undefined, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/spaces/peerings/info.js

@@ -0,0 +1,59 @@
+"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)(`
+    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.
+
+    To start the peering process, go into your AWS console for the VPC you would like peered with your Private Space,
+    navigate to the VPC service, choose the "Peering Connections" option and click the "Create peering connection" button.
+
+    - The AWS Account ID and VPC ID are necessary for the AWS VPC Peering connection wizard.
+    - You will also need to configure your VPC route table to route the Dyno CIDRs through the peering connection.
+
+    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)(`
+    $ heroku spaces:peering:info example-space
+    === example-space  Peering Info
+
+    AWS Account ID:    012345678910
+    AWS Region:        us-west-2
+    AWS VPC ID:        vpc-baadf00d
+    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 }),
+};

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

@@ -0,0 +1,15 @@
+import { Command } from '@heroku-cli/command';
+export default class Ps extends Command {
+    static topic: string;
+    static description: string;
+    static flags: {
+        space: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    static args: {
+        space: import("@oclif/core/lib/interfaces/parser").Arg<string | undefined, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+    private render;
+    private printDynos;
+}

package/lib/commands/spaces/ps.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const color_1 = require("@heroku-cli/color");
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const time_1 = require("../../lib/time");
+const getProcessNum = (s) => Number.parseInt(s.split('.', 2)[1], 10);
+class Ps extends command_1.Command {
+    async run() {
+        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(`/spaces/${spaceName}/dynos`),
+            this.heroku.get(`/spaces/${spaceName}`),
+        ]);
+        if (space.shield) {
+            spaceDynos.forEach(spaceDyno => {
+                spaceDyno.dynos.forEach(d => {
+                    var _a;
+                    if ((_a = d.size) === null || _a === void 0 ? void 0 : _a.startsWith('Private')) {
+                        d.size = d.size.replace('Private-', 'Shield-');
+                    }
+                });
+            });
+        }
+        if (flags.json) {
+            core_1.ux.styledJSON(spaceDynos);
+        }
+        else {
+            this.render(spaceDynos);
+        }
+    }
+    render(spaceDynos) {
+        spaceDynos === null || spaceDynos === void 0 ? void 0 : spaceDynos.forEach(spaceDyno => {
+            this.printDynos(spaceDyno.app_name, spaceDyno.dynos);
+        });
+    }
+    printDynos(appName, dynos) {
+        var _a, _b;
+        const dynosByCommand = new Map();
+        for (const dyno of dynos) {
+            const since = (0, time_1.ago)(new Date(dyno.updated_at));
+            const size = (_a = dyno.size) !== null && _a !== void 0 ? _a : '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_1.default.green(dyno.type)} (${color_1.default.cyan(size)}): ${dyno.command}`;
+                const state = dyno.state === 'up' ? color_1.default.green(dyno.state) : color_1.default.yellow(dyno.state);
+                item = `${dyno.name}: ${color_1.default.green(state)} ${color_1.default.dim(since)}`;
+            }
+            if (!dynosByCommand.has(key)) {
+                dynosByCommand.set(key, []);
+            }
+            (_b = dynosByCommand.get(key)) === null || _b === void 0 ? void 0 : _b.push(item);
+        }
+        for (const [key, dynos] of dynosByCommand) {
+            core_1.ux.styledHeader(`${appName} ${key} (${color_1.default.yellow(dynos.length)})`);
+            dynos.sort((a, b) => getProcessNum(a) - getProcessNum(b));
+            for (const dyno of dynos) {
+                core_1.ux.log(dyno);
+            }
+            core_1.ux.log();
+        }
+    }
+}
+exports.default = Ps;
+Ps.topic = 'spaces';
+Ps.description = 'list dynos for a space';
+Ps.flags = {
+    space: command_1.flags.string({ char: 's', description: 'space to get dynos of' }),
+    json: command_1.flags.boolean({ description: 'output in json format' }),
+};
+Ps.args = {
+    space: core_1.Args.string({ hidden: true }),
+};

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

@@ -0,0 +1,11 @@
+import { Command } from '@heroku-cli/command';
+export default class Rename extends Command {
+    static topic: string;
+    static description: string;
+    static example: string;
+    static flags: {
+        from: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        to: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/spaces/rename.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const color_1 = require("@heroku-cli/color");
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const tsheredoc_1 = require("tsheredoc");
+class Rename extends command_1.Command {
+    async run() {
+        const { flags } = await this.parse(Rename);
+        const { to, from } = flags;
+        core_1.ux.action.start(`Renaming space from ${color_1.default.cyan(from)} to ${color_1.default.green(to)}`);
+        await this.heroku.patch(`/spaces/${from}`, { body: { name: to } });
+        core_1.ux.action.stop();
+    }
+}
+exports.default = Rename;
+Rename.topic = 'spaces';
+Rename.description = 'renames a space';
+Rename.example = (0, tsheredoc_1.default)(`
+    $ heroku spaces:rename --from old-space-name --to new-space-name
+    Renaming space old-space-name to new-space-name... done
+  `);
+Rename.flags = {
+    from: command_1.flags.string({ required: true, description: 'current name of space' }),
+    to: command_1.flags.string({ required: true, description: 'desired name of space' }),
+};

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

@@ -0,0 +1,32 @@
+import { Command } from '@heroku-cli/command';
+import * as Heroku from '@heroku-cli/schema';
+export declare type SpaceTopology = {
+    version: number;
+    apps: Array<{
+        id?: string;
+        domains: string[];
+        formations: Array<{
+            process_type: string;
+            dynos: Array<{
+                number: number;
+                private_ip: string;
+                hostname: string;
+            }>;
+        }>;
+    }>;
+};
+export default class Topology extends Command {
+    static topic: string;
+    static description: string;
+    static flags: {
+        space: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    static args: {
+        space: import("@oclif/core/lib/interfaces/parser").Arg<string | undefined, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+    protected render(topology: SpaceTopology, appInfo: Heroku.App[], json: boolean): void;
+    protected getProcessType(s: string): string;
+    protected getProcessNum(s: string): number;
+}

package/lib/commands/spaces/topology.js

@@ -0,0 +1,89 @@
+"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 color_1 = require("@heroku-cli/color");
+class Topology extends command_1.Command {
+    async run() {
+        const { flags, args } = await this.parse(Topology);
+        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: topology } = await this.heroku.get(`/spaces/${spaceName}/topology`);
+        let appInfo = [];
+        if (topology.apps) {
+            appInfo = await Promise.all(topology.apps.map(async (topologyApp) => {
+                const { body: app } = await this.heroku.get(`/apps/${topologyApp.id}`);
+                return app;
+            }));
+        }
+        this.render(topology, appInfo, flags.json);
+    }
+    render(topology, appInfo, json) {
+        if (json) {
+            core_1.ux.styledJSON(topology);
+        }
+        else if (topology.apps) {
+            topology.apps.forEach(app => {
+                const formations = [];
+                const dynos = [];
+                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 === null || info === void 0 ? void 0 : info.name;
+                if (formations.length > 0) {
+                    header += ` (${color_1.default.cyan(formations.join(', '))})`;
+                }
+                core_1.ux.styledHeader(header || '');
+                core_1.ux.styledObject({
+                    Domains: domains, Dynos: dynos,
+                }, ['Domains', 'Dynos']);
+                core_1.ux.log();
+            });
+        }
+    }
+    getProcessType(s) {
+        return s.split('-', 2)[0].split('.', 2)[0];
+    }
+    getProcessNum(s) {
+        return Number.parseInt(s.split('-', 2)[0].split('.', 2)[1], 10);
+    }
+}
+exports.default = Topology;
+Topology.topic = 'spaces';
+Topology.description = 'show space topology';
+Topology.flags = {
+    space: command_1.flags.string({ char: 's', description: 'space to get topology of' }),
+    json: command_1.flags.boolean({ description: 'output in json format' }),
+};
+Topology.args = {
+    space: core_1.Args.string({ hidden: true }),
+};

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

@@ -0,0 +1,11 @@
+import { Command } from '@heroku-cli/command';
+export default class Transfer extends Command {
+    static topic: string;
+    static description: string;
+    static examples: string[];
+    static flags: {
+        space: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        team: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+    };
+    run(): Promise<void>;
+}