heroku 9.0.0-alpha.0 → 9.0.0-alpha.2

package/lib/commands/spaces/create.js

@@ -0,0 +1,73 @@
+"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 spaces_1 = require("../../lib/spaces/spaces");
+const completions_1 = require("../../lib/autocomplete/completions");
+const parsers_1 = require("../../lib/spaces/parsers");
+class Create extends command_1.Command {
+    async run() {
+        const { flags, args } = await this.parse(Create);
+        const { channel, region, features, 'log-drain-url': logDrainUrl, shield, cidr, 'kpi-url': kpiUrl, 'data-cidr': dataCidr, team } = flags;
+        const spaceName = flags.space || args.space;
+        if (!spaceName) {
+            core_1.ux.error((0, tsheredoc_1.default) `
+        Space name required.
+        USAGE: heroku spaces:create --space my-space --team my-team
+      `);
+        }
+        const dollarAmountMonthly = shield ? '$3000' : '$1000';
+        const dollarAmountHourly = shield ? '$4.17' : '$1.39';
+        const spaceType = shield ? 'Shield' : 'Standard';
+        core_1.ux.action.start(`Creating space ${color_1.default.green(spaceName)} in team ${color_1.default.cyan(team)}`);
+        const { body: space } = await this.heroku.post('/spaces', {
+            body: {
+                name: spaceName, team: team, channel_name: channel, region: region, features: (0, parsers_1.splitCsv)(features),
+                log_drain_url: logDrainUrl, shield, cidr, kpi_url: kpiUrl, data_cidr: dataCidr,
+            },
+        });
+        core_1.ux.action.stop();
+        core_1.ux.warn(`${color_1.default.bold('Spend Alert.')} During the limited GA period, each Heroku ${spaceType} Private Space costs ~${dollarAmountHourly}/hour (max ${dollarAmountMonthly}/month), pro-rated to the second.`);
+        core_1.ux.warn(`Use ${color_1.default.cmd('heroku spaces:wait')} to track allocation.`);
+        core_1.ux.styledHeader(space.name);
+        core_1.ux.styledObject({
+            ID: space.id, Team: space.team.name, Region: space.region.name, CIDR: space.cidr, 'Data CIDR': space.data_cidr, State: space.state, Shield: (0, spaces_1.displayShieldState)(space), 'Created at': space.created_at,
+        }, ['ID', 'Team', 'Region', 'CIDR', 'Data CIDR', 'State', 'Shield', 'Created at']);
+    }
+}
+exports.default = Create;
+Create.topic = 'spaces';
+Create.description = (0, tsheredoc_1.default) `
+    create a new space
+  `;
+Create.examples = [(0, tsheredoc_1.default) `
+    Example:
+
+    $ heroku spaces:create --space my-space --team my-team --region oregon
+    Creating space my-space in team my-team... done
+    === my-space
+    ID:         e7b99e37-69b3-4475-ad47-a5cc5d75fd9f
+    Team:       my-team
+    Region:     oregon
+    CIDR:       10.0.0.0/16
+    Data CIDR:  172.23.0.0/20
+    State:      allocating
+    Created at: 2016-01-06T03:23:13Z
+  `];
+Create.flags = {
+    space: command_1.flags.string({ char: 's', description: 'name of space to create' }),
+    channel: command_1.flags.string({ hidden: true }),
+    region: command_1.flags.string({ description: 'region name', completion: completions_1.RegionCompletion }),
+    features: command_1.flags.string({ hidden: true, description: 'a list of features separated by commas' }),
+    'log-drain-url': command_1.flags.string({ hidden: true, description: 'direct log drain url' }),
+    shield: command_1.flags.boolean({ hidden: true, description: 'create a Shield space' }),
+    cidr: command_1.flags.string({ description: 'RFC-1918 CIDR the space will use' }),
+    'kpi-url': command_1.flags.string({ hidden: true, description: 'self-managed KPI endpoint to use' }),
+    'data-cidr': command_1.flags.string({ description: 'RFC-1918 CIDR used by Heroku Data resources for the space' }),
+    team: command_1.flags.team({ required: true }),
+};
+Create.args = {
+    space: core_1.Args.string({ hidden: true }),
+};

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

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

package/lib/commands/spaces/destroy.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const color_1 = require("@heroku-cli/color");
+const command_1 = require("@heroku-cli/command");
+const tsheredoc_1 = require("tsheredoc");
+const confirmCommand_1 = require("../../lib/confirmCommand");
+const spaces_1 = require("../../lib/spaces/spaces");
+class Destroy extends command_1.Command {
+    async run() {
+        const { flags, args } = await this.parse(Destroy);
+        const { confirm } = flags;
+        const spaceName = flags.space || args.space;
+        if (!spaceName) {
+            core_1.ux.error((0, tsheredoc_1.default) `
+        Space name required.
+        USAGE: heroku spaces:destroy my-space
+      `);
+        }
+        let natWarning = '';
+        const { body: space } = await this.heroku.get(`/spaces/${spaceName}`);
+        if (space.state === 'allocated') {
+            ({ body: space.outbound_ips } = await this.heroku.get(`/spaces/${spaceName}/nat`));
+            if (space.outbound_ips && space.outbound_ips.state === 'enabled') {
+                natWarning = `The Outbound IPs for this space will be reused!\nEnsure that external services no longer allow these Outbound IPs: ${(0, spaces_1.displayNat)(space.outbound_ips)}\n`;
+            }
+        }
+        await (0, confirmCommand_1.default)(spaceName, confirm, `Destructive Action\nThis command will destroy the space ${color_1.default.bold.red(spaceName)}\n${natWarning}\n`);
+        core_1.ux.action.start(`Destroying space ${color_1.default.cyan(spaceName)}`);
+        await this.heroku.delete(`/spaces/${spaceName}`);
+        core_1.ux.action.stop();
+    }
+}
+exports.default = Destroy;
+Destroy.topic = 'spaces';
+Destroy.description = (0, tsheredoc_1.default) `
+    destroy a space
+  `;
+Destroy.examples = [(0, tsheredoc_1.default) `
+    $ heroku spaces:destroy --space my-space
+    Destroying my-space... done
+  `];
+Destroy.flags = {
+    space: command_1.flags.string({ char: 's', description: 'space to destroy' }),
+    confirm: command_1.flags.string({ description: 'set to space name to bypass confirm prompt', hasValue: true }),
+};
+Destroy.args = {
+    space: core_1.Args.string({ hidden: true }),
+};

package/lib/commands/spaces/drains/get.d.ts

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

package/lib/commands/spaces/drains/get.js

@@ -0,0 +1,27 @@
+"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");
+class Get extends command_1.Command {
+    async run() {
+        const { flags } = await this.parse(Get);
+        const { space, json } = flags;
+        const { body: drain } = await this.heroku.get(`/spaces/${space}/log-drain`, { headers: { Accept: 'application/vnd.heroku+json; version=3.dogwood' } });
+        if (json) {
+            core_1.ux.log(JSON.stringify(drain, null, 2));
+        }
+        else {
+            core_1.ux.log(`${color_1.default.cyan(drain.url)} (${color_1.default.green(drain.token)})`);
+        }
+    }
+}
+exports.default = Get;
+Get.topic = 'spaces';
+Get.aliases = ['drains:get'];
+Get.hidden = true;
+Get.description = 'display the log drain for a space';
+Get.flags = {
+    space: command_1.flags.string({ char: 's', description: 'space for which to get log drain', required: true }),
+    json: command_1.flags.boolean({ description: 'output in json format' }),
+};

package/lib/commands/spaces/drains/set.d.ts

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

package/lib/commands/spaces/drains/set.js

@@ -0,0 +1,29 @@
+"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");
+class Set extends command_1.Command {
+    async run() {
+        const { flags, args } = await this.parse(Set);
+        const { url } = args;
+        const { space } = flags;
+        const { body: drain } = await this.heroku.put(`/spaces/${space}/log-drain`, {
+            body: { url },
+            headers: { Accept: 'application/vnd.heroku+json; version=3.dogwood' },
+        });
+        core_1.ux.log(`Successfully set drain ${color_1.default.cyan(drain.url)} for ${color_1.default.cyan.bold(space)}.`);
+        core_1.ux.warn('It may take a few moments for the changes to take effect.');
+    }
+}
+exports.default = Set;
+Set.topic = 'spaces';
+Set.aliases = ['drains:set'];
+Set.hidden = true;
+Set.description = 'replaces the log drain for a space';
+Set.flags = {
+    space: command_1.flags.string({ char: 's', description: 'space for which to set log drain', required: true }),
+};
+Set.args = {
+    url: core_1.Args.string({ required: true }),
+};

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

@@ -0,0 +1,14 @@
+import { Command } from '@heroku-cli/command';
+export default class Hosts extends Command {
+    static topic: string;
+    static hidden: boolean;
+    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/hosts.js

@@ -0,0 +1,37 @@
+"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 hosts_1 = require("../../lib/spaces/hosts");
+class Hosts extends command_1.Command {
+    async run() {
+        const { flags, args } = await this.parse(Hosts);
+        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: hosts } = await this.heroku.get(`/spaces/${spaceName}/hosts`, {
+            headers: { Accept: 'application/vnd.heroku+json; version=3.dogwood' },
+        });
+        if (flags.json)
+            (0, hosts_1.displayHostsAsJSON)(hosts);
+        else
+            (0, hosts_1.displayHosts)(spaceName, hosts);
+    }
+}
+exports.default = Hosts;
+Hosts.topic = 'spaces';
+Hosts.hidden = true;
+Hosts.description = 'list dedicated hosts for a space';
+Hosts.flags = {
+    space: command_1.flags.string({ char: 's', description: 'space to get host list from' }),
+    json: command_1.flags.boolean({ description: 'output in json format' }),
+};
+Hosts.args = {
+    space: core_1.Args.string({ hidden: true }),
+};

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

@@ -0,0 +1,16 @@
+import { Command } from '@heroku-cli/command';
+import * as Heroku from '@heroku-cli/schema';
+declare type SpaceArray = Array<Required<Heroku.Space>>;
+export default class Index extends Command {
+    static topic: string;
+    static description: string;
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        team: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+    };
+    run(): Promise<void>;
+    protected sortByName(spaces: SpaceArray): SpaceArray;
+    protected displayJSON(spaces: SpaceArray): void;
+    protected display(spaces: SpaceArray): void;
+}
+export {};

package/lib/commands/spaces/index.js

@@ -0,0 +1,55 @@
+"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");
+class Index extends command_1.Command {
+    async run() {
+        const { flags } = await this.parse(Index);
+        const { team, json } = flags;
+        let { body: spaces } = await this.heroku.get('/spaces');
+        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)
+                core_1.ux.error(`No spaces in ${color_1.default.cyan(team)}.`);
+            else
+                core_1.ux.error('You do not have access to any spaces.');
+        }
+        else {
+            this.display(spaces);
+        }
+    }
+    sortByName(spaces) {
+        spaces.sort((a, b) => {
+            return a.name === b.name ? 0 : (a.name < b.name ? -1 : 1);
+        });
+        return spaces;
+    }
+    displayJSON(spaces) {
+        core_1.ux.log(JSON.stringify(spaces, null, 2));
+    }
+    display(spaces) {
+        core_1.ux.table(spaces, {
+            Name: { get: space => space.name },
+            Team: { get: space => space.team.name },
+            Region: { get: space => space.region.name },
+            State: { get: space => space.state },
+            createdAt: {
+                header: 'Created At',
+                get: space => space.created_at,
+            },
+        });
+    }
+}
+exports.default = Index;
+Index.topic = 'spaces';
+Index.description = 'list available spaces';
+Index.flags = {
+    json: command_1.flags.boolean({ description: 'output in json format' }),
+    team: command_1.flags.team(),
+};

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

@@ -0,0 +1,14 @@
+import { Command } from '@heroku-cli/command';
+export default class Info extends Command {
+    static topic: string;
+    static description: string;
+    static example: 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/info.js

@@ -0,0 +1,47 @@
+"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 spaces_1 = require("../../lib/spaces/spaces");
+const debug_1 = require("debug");
+const spacesDebug = (0, debug_1.default)('spaces:info');
+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
+      `));
+        }
+        let headers = {};
+        if (!flags.json) {
+            headers = { 'Accept-Expansion': 'region' };
+        }
+        const { body: space } = await this.heroku.get(`/spaces/${spaceName}`, { headers });
+        if (space.state === 'allocated') {
+            try {
+                const { body: outbound_ips } = await this.heroku.get(`/spaces/${spaceName}/nat`);
+                space.outbound_ips = outbound_ips;
+            }
+            catch (error) {
+                spacesDebug(`Retrieving NAT details for the space failed with ${error}`);
+            }
+        }
+        (0, spaces_1.renderInfo)(space, flags.json);
+    }
+}
+exports.default = Info;
+Info.topic = 'spaces';
+Info.description = 'show info about a space';
+Info.example = '$ heroku spaces:info my-space';
+Info.flags = {
+    space: command_1.flags.string({ char: 's', description: 'space to get info of' }),
+    json: command_1.flags.boolean({ description: 'output in json format' }),
+};
+Info.args = {
+    space: core_1.Args.string({ hidden: true }),
+};

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

@@ -0,0 +1,15 @@
+import { Command } from '@heroku-cli/command';
+export default class Add 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, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        dest: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        protocol: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        port: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

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

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@heroku-cli/command");
+const color_1 = require("@heroku-cli/color");
+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");
+const completions_2 = require("../../../lib/autocomplete/completions");
+class Add extends command_1.Command {
+    async run() {
+        const { flags } = await this.parse(Add);
+        const { space, dest, protocol, port } = flags;
+        const { body: ruleset } = await this.heroku.get(`/spaces/${space}/outbound-ruleset`, {
+            headers: { Accept: 'application/vnd.heroku+json; version=3.dogwood' },
+        });
+        ruleset.rules = ruleset.rules || [];
+        const ports = (0, outbound_rules_1.parsePorts)(protocol, port);
+        ruleset.rules.push({
+            target: dest, from_port: ports[0], to_port: ports[1] || ports[0], protocol: protocol,
+        });
+        core_1.ux.action.start(`Adding rule to the Outbound Rules of ${color_1.default.cyan.bold(space)}`);
+        await this.heroku.put(`/spaces/${space}/outbound-ruleset`, {
+            headers: { Accept: 'application/vnd.heroku+json; version=3.dogwood' },
+            body: ruleset,
+        });
+        core_1.ux.action.stop();
+        core_1.ux.warn('Modifying the Outbound Rules may break Add-ons for Apps in this Private Space');
+    }
+}
+exports.default = Add;
+Add.topic = 'spaces';
+Add.aliases = ['outbound-rules:add'];
+Add.description = (0, tsheredoc_1.default)(`
+    Add outbound rules to a Private Space
+
+    The destination flag uses CIDR notation.
+
+    ICMP Rules
+    The ICMP protocol has types, not ports, but the underlying systems treat them as the same. For this reason,
+    when you want to allow ICMP traffic you will use the --port flag to specify the ICMP types you want to
+    allow. ICMP types are numbered, 0-255.
+  `);
+Add.examples = [
+    (0, tsheredoc_1.default)(`
+      $ heroku outbound-rules:add --space my-space --dest 192.168.2.0/24 --protocol tcp --port 80
+      Adding rule to the Outbound Rules of my-space... done
+    `),
+    (0, tsheredoc_1.default)(`
+      # with port range:
+      $ heroku outbound-rules:add --space my-space --dest 192.168.2.0/24 --protocol tcp --port 80-100
+      Adding rule to the Outbound Rules of my-space... done
+    `),
+    (0, tsheredoc_1.default)(`
+      # opening up everything
+      $ heroku outbound-rules:add --space my-space --dest 0.0.0.0/0 --protocol any --port any
+      Adding rule to the Outbound Rules of my-space... done
+    `),
+];
+Add.hidden = true;
+Add.flags = {
+    space: command_1.flags.string({
+        char: 's',
+        description: 'space to add rule to',
+        required: true,
+        completion: completions_1.SpaceCompletion,
+    }),
+    dest: command_1.flags.string({
+        description: 'target CIDR block dynos are allowed to communicate with',
+        required: true,
+    }),
+    protocol: command_1.flags.string({
+        description: 'the protocol dynos are allowed to use when communicating with hosts in destination CIDR block.',
+        completion: completions_2.ProtocolCompletion,
+        options: ['tcp', 'udp', 'icmp', '0-255', 'any'],
+        required: true,
+    }),
+    port: command_1.flags.string({
+        description: 'the port dynos are allowed to use when communicating with hosts in destination CIDR block. Accepts a range in `<lowest port>-<highest port>` format. 0 is the minimum. The maximum port allowed is 65535, except for ICMP with a maximum of 255.',
+    }),
+};

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

@@ -0,0 +1,15 @@
+import { Command } from '@heroku-cli/command';
+export default class Index extends Command {
+    static topic: string;
+    static aliases: string[];
+    static description: string;
+    static hidden: boolean;
+    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/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 }),
+};