heroku 9.0.0-dev.0 → 9.1.0-beta.0

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

package/lib/commands/spaces/transfer.js

@@ -0,0 +1,35 @@
+"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 Transfer extends command_1.Command {
+    async run() {
+        const { flags } = await this.parse(Transfer);
+        const space = flags.space;
+        const team = flags.team;
+        try {
+            core_1.ux.action.start(`Transferring space ${color_1.default.yellow(space)} to team ${color_1.default.green(team)}`);
+            await this.heroku.post(`/spaces/${space}/transfer`, { body: { new_owner: team } });
+        }
+        catch (error) {
+            const { body: { message } } = error;
+            core_1.ux.error(message);
+        }
+        finally {
+            core_1.ux.action.stop();
+        }
+    }
+}
+exports.default = Transfer;
+Transfer.topic = 'spaces';
+Transfer.description = 'transfer a space to another team';
+Transfer.examples = [(0, tsheredoc_1.default)(`
+  $ heroku spaces:transfer --space=space-name --team=team-name
+  Transferring space-name to team-name... done
+  `)];
+Transfer.flags = {
+    space: command_1.flags.string({ required: true, char: 's', description: 'name of space' }),
+    team: command_1.flags.string({ required: true, char: 't', description: 'desired owner of space' }),
+};

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

@@ -0,0 +1,16 @@
+import { Command } from '@heroku-cli/command';
+export default class Add extends Command {
+    static topic: string;
+    static hiddenAliases: string[];
+    static description: string;
+    static examples: string[];
+    static flags: {
+        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: {
+        source: import("@oclif/core/lib/interfaces/parser").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+    private isUniqueRule;
+}

package/lib/commands/spaces/trusted-ips/add.js

@@ -0,0 +1,43 @@
+"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 Add extends command_1.Command {
+    async run() {
+        const { flags, args } = await this.parse(Add);
+        const { space } = flags;
+        const url = `/spaces/${space}/inbound-ruleset`;
+        const options = {
+            headers: { Accept: 'application/vnd.heroku+json; version=3.dogwood' },
+        };
+        const { body: ruleset } = await this.heroku.get(url, options);
+        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, Object.assign(Object.assign({}, options), { body: ruleset }));
+        core_1.ux.log(`Added ${color_1.default.cyan.bold(args.source)} to trusted IP ranges on ${color_1.default.cyan.bold(space)}`);
+        core_1.ux.warn('It may take a few moments for the changes to take effect.');
+    }
+    isUniqueRule(ruleset, source) {
+        return Array.isArray(ruleset.rules) && !ruleset.rules.some(rs => rs.source === source);
+    }
+}
+exports.default = Add;
+Add.topic = 'spaces';
+Add.hiddenAliases = ['trusted-ips:add'];
+Add.description = (0, tsheredoc_1.default)(`
+  Add one range to the list of trusted IP ranges
+  Uses CIDR notation.`);
+Add.examples = [(0, tsheredoc_1.default)(`
+  $ 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`)];
+Add.flags = {
+    space: command_1.flags.string({ char: 's', description: 'space to add rule to', required: true }),
+    confirm: command_1.flags.string({ description: 'set to space name to bypass confirm prompt' }),
+};
+Add.args = {
+    source: core_1.Args.string({ required: true }),
+};

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

@@ -0,0 +1,15 @@
+import { Command } from '@heroku-cli/command';
+export default class Index 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 args: {
+        space: import("@oclif/core/lib/interfaces/parser").Arg<string | undefined, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+    private displayRules;
+}

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

@@ -0,0 +1,52 @@
+"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");
+class Index extends command_1.Command {
+    async run() {
+        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(`/spaces/${space}/inbound-ruleset`, {
+            headers: { Accept: 'application/vnd.heroku+json; version=3.dogwood' },
+        });
+        if (flags.json) {
+            core_1.ux.log(JSON.stringify(rules, null, 2));
+        }
+        else {
+            this.displayRules(space, rules);
+        }
+    }
+    displayRules(space, ruleset) {
+        if (ruleset.rules.length > 0) {
+            core_1.ux.styledHeader('Trusted IP Ranges');
+            for (const rule of ruleset.rules) {
+                core_1.ux.log(rule.source);
+            }
+        }
+        else {
+            core_1.ux.styledHeader(`${space} has no trusted IP ranges. All inbound web requests to dynos are blocked.`);
+        }
+    }
+}
+exports.default = Index;
+Index.topic = 'spaces';
+Index.hiddenAliases = ['trusted-ips'];
+Index.description = (0, tsheredoc_1.default)(`
+  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:
+  `);
+Index.flags = {
+    space: command_1.flags.string({ char: 's', description: 'space to get inbound rules from' }),
+    json: command_1.flags.boolean({ description: 'output in json format' }),
+};
+Index.args = {
+    space: core_1.Args.string({ hidden: true }),
+};

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

@@ -0,0 +1,15 @@
+import { Command } from '@heroku-cli/command';
+export default class Remove extends Command {
+    static topic: string;
+    static hiddenAliases: string[];
+    static description: string;
+    static examples: string[];
+    static flags: {
+        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: {
+        source: import("@oclif/core/lib/interfaces/parser").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}