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

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

@@ -0,0 +1,44 @@
+"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 Remove extends command_1.Command {
+    async run() {
+        var _a, _b, _c, _d;
+        const { flags, args } = await this.parse(Remove);
+        const space = flags.space;
+        const url = `/spaces/${space}/inbound-ruleset`;
+        const opts = { headers: { Accept: 'application/vnd.heroku+json; version=3.dogwood' } };
+        const { body: rules } = await this.heroku.get(url, opts);
+        if (((_a = rules.rules) === null || _a === void 0 ? void 0 : _a.length) === 0) {
+            throw new Error('No IP ranges are configured. Nothing to do.');
+        }
+        const originalLength = (_b = rules.rules) === null || _b === void 0 ? void 0 : _b.length;
+        rules.rules = (_c = rules.rules) === null || _c === void 0 ? void 0 : _c.filter(r => r.source !== args.source);
+        if (((_d = rules.rules) === null || _d === void 0 ? void 0 : _d.length) === originalLength) {
+            throw new Error(`No IP range matching ${args.source} was found.`);
+        }
+        await this.heroku.put(url, Object.assign(Object.assign({}, opts), { body: rules }));
+        core_1.ux.log(`Removed ${color_1.default.cyan.bold(args.source)} from 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.');
+    }
+}
+exports.default = Remove;
+Remove.topic = 'spaces';
+Remove.hiddenAliases = ['trusted-ips:remove'];
+Remove.description = (0, tsheredoc_1.default)(`
+  Remove a range from the list of trusted IP ranges
+  Uses CIDR notation.`);
+Remove.examples = [(0, tsheredoc_1.default)(`
+  $ heroku trusted-ips:remove --space my-space 192.168.2.0/24
+      Removed 192.168.2.0/24 from trusted IP ranges on my-space
+        `)];
+Remove.flags = {
+    space: command_1.flags.string({ required: true, char: 's', description: 'space to remove rule from' }),
+    confirm: command_1.flags.string({ description: 'set to space name to bypass confirm prompt' }),
+};
+Remove.args = {
+    source: core_1.Args.string({ required: true }),
+};

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

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

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

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const vpn_connections_1 = require("../../../lib/spaces/vpn-connections");
+const tsheredoc_1 = require("tsheredoc");
+class Config extends command_1.Command {
+    async run() {
+        const { flags, args } = await this.parse(Config);
+        const { space, json } = flags;
+        const { name } = args;
+        const { body: vpnConnection } = await this.heroku.get(`/spaces/${space}/vpn-connections/${name}`);
+        if (json) {
+            core_1.ux.styledJSON(vpnConnection);
+        }
+        else {
+            (0, vpn_connections_1.displayVPNConfigInfo)(space, name, vpnConnection);
+        }
+    }
+}
+exports.default = Config;
+Config.topic = 'spaces';
+Config.description = (0, tsheredoc_1.default)(`
+    display the configuration information for VPN
+
+    You will use the information provided by this command to establish a Private Space VPN Connection.
+
+    - You must configure your VPN Gateway to use both Tunnels provided by Heroku
+    - The VPN Gateway values are the IP addresses of the Private Space Tunnels
+    - The Customer Gateway value is the Public IP of your VPN Gateway
+    - The VPN Gateway must use the IKE Version shown and the Pre-shared Keys as the authentication method
+  `);
+Config.example = (0, tsheredoc_1.default)(`
+    $ heroku spaces:vpn:config vpn-connection-name --space my-space
+    === vpn-connection-name VPN Tunnels
+     VPN Tunnel Customer Gateway VPN Gateway    Pre-shared Key Routable Subnets IKE Version
+     ────────── ──────────────── ────────────── ────────────── ──────────────── ───────────
+     Tunnel 1    104.196.121.200   35.171.237.136  abcdef12345     10.0.0.0/16       1
+     Tunnel 2    104.196.121.200   52.44.7.216     fedcba54321     10.0.0.0/16       1
+    `);
+Config.flags = {
+    space: command_1.flags.string({
+        required: true,
+        char: 's',
+        description: 'space the VPN connection belongs to',
+    }),
+    json: command_1.flags.boolean({ description: 'output in json format' }),
+};
+Config.args = {
+    name: core_1.Args.string({
+        required: true,
+        description: 'name or id of the VPN connection to retrieve config from',
+    }),
+};

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

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

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

@@ -0,0 +1,48 @@
+"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 parsers_1 = require("../../../lib/spaces/parsers");
+class Connect extends command_1.Command {
+    async run() {
+        const { flags, args } = await this.parse(Connect);
+        const { space, cidrs, ip } = flags;
+        const { name } = args;
+        const parsed_cidrs = (0, parsers_1.splitCsv)(cidrs);
+        core_1.ux.action.start(`Creating VPN Connection in space ${color_1.default.green(space)}`);
+        await this.heroku.post(`/spaces/${space}/vpn-connections`, {
+            body: {
+                name,
+                public_ip: ip,
+                routable_cidrs: parsed_cidrs,
+            },
+        });
+        core_1.ux.action.stop();
+        core_1.ux.warn(`Use ${color_1.default.cmd('heroku spaces:vpn:wait')} to track allocation.`);
+    }
+}
+exports.default = Connect;
+Connect.topic = 'spaces';
+Connect.description = (0, tsheredoc_1.default) `
+    create VPN
+    Private Spaces can be connected to another private network via an IPSec VPN connection allowing dynos to connect to hosts on your private networks and vice versa.
+    The connection is established over the public Internet but all traffic is encrypted using IPSec.
+  `;
+Connect.examples = [(0, tsheredoc_1.default) `
+    $ heroku spaces:vpn:connect vpn-connection-name --ip 35.161.69.30 --cidrs 172.16.0.0/16,10.0.0.0/24 --space my-space
+    Creating VPN Connection in space my-space... done
+    ▸    Use spaces:vpn:wait to track allocation.
+  `];
+Connect.flags = {
+    ip: command_1.flags.string({ char: 'i', description: 'public IP of customer gateway', required: true }),
+    cidrs: command_1.flags.string({ char: 'c', description: 'a list of routable CIDRs separated by commas', required: true }),
+    space: command_1.flags.string({ char: 's', description: 'space name', required: true }),
+};
+Connect.args = {
+    name: core_1.Args.string({
+        required: true,
+        description: 'name or id of the VPN connection to create',
+    }),
+};

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

@@ -0,0 +1,17 @@
+import { Command } from '@heroku-cli/command';
+import * as Heroku from '@heroku-cli/schema';
+declare type VpnConnectionTunnels = Required<Heroku.PrivateSpacesVpn>['tunnels'];
+export default class Connections extends Command {
+    static topic: string;
+    static description: string;
+    static example: 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>;
+    protected render(space: string, connections: Required<Heroku.PrivateSpacesVpn>[], json: boolean): void;
+    protected displayVPNConnections(space: string, connections: Required<Heroku.PrivateSpacesVpn>[]): void;
+    protected tunnelFormat(t: VpnConnectionTunnels): string;
+}
+export {};

package/lib/commands/spaces/vpn/connections.js

@@ -0,0 +1,57 @@
+"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 format_1 = require("../../../lib/spaces/format");
+class Connections extends command_1.Command {
+    async run() {
+        const { flags } = await this.parse(Connections);
+        const { space, json } = flags;
+        const { body: connections } = await this.heroku.get(`/spaces/${space}/vpn-connections`);
+        this.render(space, connections, json);
+    }
+    render(space, connections, json) {
+        if (json) {
+            core_1.ux.styledJSON(connections);
+        }
+        else {
+            this.displayVPNConnections(space, connections);
+        }
+    }
+    displayVPNConnections(space, connections) {
+        if (connections.length === 0) {
+            core_1.ux.log('No VPN Connections have been created yet');
+            return;
+        }
+        core_1.ux.styledHeader(`${space} VPN Connections`);
+        core_1.ux.table(connections, {
+            Name: {
+                get: c => c.name || c.id,
+            },
+            Status: {
+                get: c => (0, format_1.displayVPNStatus)(c.status),
+            },
+            Tunnels: {
+                get: c => this.tunnelFormat(c.tunnels),
+            },
+        });
+    }
+    tunnelFormat(t) {
+        return t.map(tunnel => (0, format_1.displayVPNStatus)(tunnel.status)).join('/');
+    }
+}
+exports.default = Connections;
+Connections.topic = 'spaces';
+Connections.description = 'list the VPN Connections for a space';
+Connections.example = (0, tsheredoc_1.default) `
+    $ heroku spaces:vpn:connections --space my-space
+    === my-space VPN Connections
+     Name   Status Tunnels 
+     ────── ────── ─────── 
+     office active UP/UP   
+  `;
+Connections.flags = {
+    space: command_1.flags.string({ char: 's', description: 'space to get VPN connections from', required: true }),
+    json: command_1.flags.boolean({ description: 'output in json format' }),
+};

package/lib/commands/spaces/vpn/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, 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: {
+        name: import("@oclif/core/lib/interfaces/parser").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}

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

@@ -0,0 +1,38 @@
+"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 confirmCommand_1 = require("../../../lib/confirmCommand");
+const tsheredoc_1 = require("tsheredoc");
+class Destroy extends command_1.Command {
+    async run() {
+        const { flags, args } = await this.parse(Destroy);
+        const { space, confirm } = flags;
+        const { name } = args;
+        await (0, confirmCommand_1.default)(name, confirm, (0, tsheredoc_1.default) `
+        Destructive Action
+        This command will attempt to destroy the specified VPN Connection in space ${color_1.default.green(space)}
+      `);
+        core_1.ux.action.start(`Tearing down VPN Connection ${color_1.default.cyan(name)} in space ${color_1.default.cyan(space)}`);
+        await this.heroku.delete(`/spaces/${space}/vpn-connections/${name}`);
+        core_1.ux.action.stop();
+    }
+}
+exports.default = Destroy;
+Destroy.topic = 'spaces';
+Destroy.description = 'destroys VPN in a private space';
+Destroy.examples = [(0, tsheredoc_1.default) `
+    $ heroku spaces:vpn:destroy vpn-connection-name --space example-space --confirm vpn-connection-name
+    Tearing down VPN Connection vpn-connection-name in space example-space
+  `];
+Destroy.flags = {
+    space: command_1.flags.string({ char: 's', description: 'space name', required: true }),
+    confirm: command_1.flags.string({ description: 'set to VPN connection name to bypass confirm prompt', hidden: true }),
+};
+Destroy.args = {
+    name: core_1.Args.string({
+        required: true,
+        description: 'name or id of the VPN connection to destroy',
+    }),
+};

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

@@ -0,0 +1,16 @@
+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, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    static args: {
+        name: import("@oclif/core/lib/interfaces/parser").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+    private displayVPNInfo;
+    private render;
+}

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

@@ -0,0 +1,82 @@
+"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 format_1 = require("../../../lib/spaces/format");
+class Info extends command_1.Command {
+    async run() {
+        const { flags, args } = await this.parse(Info);
+        const { space, json } = flags;
+        const { name } = args;
+        const { body: vpnConnection } = await this.heroku.get(`/spaces/${space}/vpn-connections/${name}`);
+        const connectionName = vpnConnection.name || name;
+        this.render(connectionName, vpnConnection, json);
+    }
+    displayVPNInfo(name, vpnConnection) {
+        core_1.ux.styledHeader(`${name} VPN Info`);
+        core_1.ux.styledObject({
+            Name: name,
+            ID: vpnConnection.id,
+            'Public IP': vpnConnection.public_ip,
+            'Routable CIDRs': (0, format_1.displayCIDR)(vpnConnection.routable_cidrs),
+            Status: `${(0, format_1.displayVPNStatus)(vpnConnection.status)}`,
+            'Status Message': vpnConnection.status_message,
+        }, ['Name', 'ID', 'Public IP', 'Routable CIDRs', 'State', 'Status', 'Status Message']);
+        const vpnConnectionTunnels = vpnConnection.tunnels || [];
+        vpnConnectionTunnels.forEach((val, i) => {
+            val.tunnel_id = 'Tunnel ' + (i + 1);
+        });
+        core_1.ux.styledHeader(`${name} VPN Tunnel Info`);
+        core_1.ux.table(vpnConnectionTunnels, {
+            tunnel_id: { header: 'VPN Tunnel' },
+            ip: { header: 'IP Address' },
+            status: {
+                header: 'Status',
+                get: row => (0, format_1.displayVPNStatus)(row.status),
+            },
+            last_status_change: { header: 'Status Last Changed' },
+            status_message: { header: 'Details' },
+        });
+    }
+    render(name, vpnConnection, json) {
+        if (json) {
+            core_1.ux.styledJSON(vpnConnection);
+        }
+        else {
+            this.displayVPNInfo(name, vpnConnection);
+        }
+    }
+}
+exports.default = Info;
+Info.topic = 'spaces';
+Info.description = 'display the information for VPN';
+Info.example = (0, tsheredoc_1.default)(`
+    $ heroku spaces:vpn:info vpn-connection-name --space my-space
+    === vpn-connection-name VPN Tunnel Info
+    Name:           vpn-connection-name
+    ID:             123456789012
+    Public IP:      35.161.69.30
+    Routable CIDRs: 172.16.0.0/16
+    Status:         failed
+    Status Message: supplied CIDR block already in use
+    === my-space Tunnel Info
+     VPN Tunnel IP Address    Status Last Changed         Details
+     ────────── ───────────── ────── ──────────────────── ─────────────
+     Tunnel 1   52.44.146.197 UP     2016-10-25T22:09:05Z status message
+     Tunnel 2   52.44.146.197 UP     2016-10-25T22:09:05Z status message
+  `);
+Info.flags = {
+    space: command_1.flags.string({
+        char: 's',
+        description: 'space the vpn connection belongs to',
+        required: true,
+    }),
+    json: command_1.flags.boolean({ description: 'output in json format' }),
+};
+Info.args = {
+    name: core_1.Args.string({
+        description: 'name or id of the VPN connection to get info from',
+        required: true,
+    }),
+};

package/lib/commands/spaces/vpn/update.d.ts

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

package/lib/commands/spaces/vpn/update.js

@@ -0,0 +1,39 @@
+"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 parsers_1 = require("../../../lib/spaces/parsers");
+const tsheredoc_1 = require("tsheredoc");
+class Update extends command_1.Command {
+    async run() {
+        const { flags, args } = await this.parse(Update);
+        const { space, cidrs } = flags;
+        const { name } = args;
+        const parsedCidrs = (0, parsers_1.splitCsv)(cidrs);
+        core_1.ux.action.start(`Updating VPN Connection in space ${color_1.default.green(space)}`);
+        await this.heroku.patch(`/spaces/${space}/vpn-connections/${name}`, { body: { routable_cidrs: parsedCidrs } });
+        core_1.ux.action.stop();
+    }
+}
+exports.default = Update;
+Update.topic = 'spaces';
+Update.description = (0, tsheredoc_1.default) `
+    update VPN
+    Private Spaces can be connected to another private network via an IPSec VPN connection allowing dynos to connect to hosts on your private networks and vice versa.
+    The connection is established over the public Internet but all traffic is encrypted using IPSec.
+  `;
+Update.flags = {
+    cidrs: command_1.flags.string({ char: 'c', description: 'a list of routable CIDRs separated by commas', required: true }),
+    space: command_1.flags.string({ char: 's', description: 'space name', required: true }),
+};
+Update.example = (0, tsheredoc_1.default) `
+    $ heroku spaces:vpn:update vpn-connection-name --space my-space --cidrs 172.16.0.0/16,10.0.0.0/24
+    Updating VPN Connection in space my-space... done
+  `;
+Update.args = {
+    name: core_1.Args.string({
+        required: true,
+        description: 'name or id of the VPN connection to update',
+    }),
+};

package/lib/commands/spaces/vpn/wait.d.ts

@@ -0,0 +1,16 @@
+import { Command } from '@heroku-cli/command';
+export default class Wait 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>;
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        interval: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        timeout: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+    };
+    static args: {
+        name: import("@oclif/core/lib/interfaces/parser").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/spaces/vpn/wait.js

@@ -0,0 +1,70 @@
+"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 vpn_connections_1 = require("../../../lib/spaces/vpn-connections");
+const tsheredoc_1 = require("tsheredoc");
+const wait = (ms) => new Promise(resolve => {
+    setTimeout(resolve, ms);
+});
+class Wait extends command_1.Command {
+    async run() {
+        const { flags, args } = await this.parse(Wait);
+        const { space, json } = flags;
+        const { name } = args;
+        const interval = (flags.interval ? Number.parseInt(flags.interval, 10) : 10) * 1000;
+        const timeout = (flags.timeout ? Number.parseInt(flags.timeout, 10) : 20 * 60) * 1000;
+        const deadline = new Date(Date.now() + timeout);
+        let { body: vpnConnection } = await this.heroku.get(`/spaces/${space}/vpn-connections/${name}`);
+        if (vpnConnection.status === 'active') {
+            core_1.ux.log('VPN has been allocated.');
+            return;
+        }
+        core_1.ux.action.start(`Waiting for VPN Connection ${color_1.default.green(name)} to allocate...`);
+        while (vpnConnection.status !== 'active') {
+            if (new Date() > deadline) {
+                core_1.ux.error('Timeout waiting for VPN to become allocated.', { exit: 1 });
+            }
+            if (vpnConnection.status === 'failed') {
+                core_1.ux.error(vpnConnection.status_message || '', { exit: 1 });
+            }
+            await wait(interval);
+            const { body: updatedVpnConnection } = await this.heroku.get(`/spaces/${space}/vpn-connections/${name}`);
+            vpnConnection = updatedVpnConnection;
+        }
+        core_1.ux.action.stop();
+        const { body: newVpnConnection } = await this.heroku.get(`/spaces/${space}/vpn-connections/${name}`);
+        if (json) {
+            core_1.ux.styledJSON(newVpnConnection);
+        }
+        else {
+            (0, vpn_connections_1.displayVPNConfigInfo)(space, name, newVpnConnection);
+        }
+    }
+}
+exports.default = Wait;
+Wait.topic = 'spaces';
+Wait.description = 'wait for VPN Connection to be created';
+Wait.examples = [(0, tsheredoc_1.default) `
+      $ heroku spaces:vpn:wait vpn-connection-name --space my-space
+      Waiting for VPN Connection vpn-connection-name to allocate... done
+      === my-space VPN Tunnels
+
+     VPN Tunnel Customer Gateway VPN Gateway    Pre-shared Key Routable Subnets IKE Version
+     ────────── ──────────────── ────────────── ────────────── ──────────────── ───────────
+     Tunnel 1    104.196.121.200   35.171.237.136  abcdef12345     10.0.0.0/16       1
+     Tunnel 2    104.196.121.200   52.44.7.216     fedcba54321     10.0.0.0/16       1
+    `];
+Wait.flags = {
+    space: command_1.flags.string({ char: 's', description: 'space the vpn connection belongs to', required: true }),
+    json: command_1.flags.boolean({ description: 'output in json format' }),
+    interval: command_1.flags.string({ char: 'i', description: 'seconds to wait between poll intervals' }),
+    timeout: command_1.flags.string({ char: 't', description: 'maximum number of seconds to wait' }),
+};
+Wait.args = {
+    name: core_1.Args.string({
+        description: 'name or id of the VPN connection you are waiting on for allocation.',
+        required: true,
+    }),
+};

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

@@ -0,0 +1,17 @@
+import { Command } from '@heroku-cli/command';
+export default class Wait 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>;
+        interval: import("@oclif/core/lib/interfaces").OptionFlag<number, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        timeout: import("@oclif/core/lib/interfaces").OptionFlag<number, 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>;
+    protected wait(ms: number): Promise<unknown>;
+    protected notify(spaceName: string): void;
+}

package/lib/commands/spaces/wait.js

@@ -0,0 +1,89 @@
+"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 spinner_1 = require("@oclif/core/lib/cli-ux/action/spinner");
+const debug_1 = require("debug");
+const spaces_1 = require("../../lib/spaces/spaces");
+const notifications_1 = require("@heroku-cli/notifications");
+const spacesDebug = (0, debug_1.default)('spaces:wait');
+class Wait extends command_1.Command {
+    async run() {
+        const { flags, args } = await this.parse(Wait);
+        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 interval = flags.interval * 1000;
+        const timeout = flags.timeout * 1000;
+        const deadline = new Date(Date.now() + timeout);
+        const action = new spinner_1.default();
+        action.start(`Waiting for space ${color_1.default.green(spaceName)} to allocate`);
+        let headers = {};
+        if (!flags.json) {
+            headers = { 'Accept-Expansion': 'region' };
+        }
+        let { body: space } = await this.heroku.get(`/spaces/${spaceName}`, { headers });
+        while (space.state === 'allocating') {
+            if (new Date() > deadline) {
+                throw new Error('Timeout waiting for space to become allocated.');
+            }
+            await this.wait(interval);
+            const { body: updatedSpace } = await this.heroku.get(`/spaces/${spaceName}`, { headers });
+            space = updatedSpace;
+        }
+        try {
+            const { body: nat } = await this.heroku.get(`/spaces/${spaceName}/nat`);
+            space.outbound_ips = nat;
+        }
+        catch (error) {
+            spacesDebug(`Retrieving NAT details for the space failed with ${error}`);
+        }
+        action.stop();
+        (0, spaces_1.renderInfo)(space, flags.json);
+        this.notify(spaceName);
+    }
+    wait(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+    notify(spaceName) {
+        try {
+            const notification = {
+                title: spaceName,
+                subtitle: `heroku spaces:wait ${spaceName}`,
+                message: 'space was successfully created',
+                sound: true,
+            };
+            (0, notifications_1.notify)(notification);
+        }
+        catch (error) {
+            core_1.ux.warn(error);
+        }
+    }
+}
+exports.default = Wait;
+Wait.topic = 'spaces';
+Wait.description = 'wait for a space to be created';
+Wait.flags = {
+    space: command_1.flags.string({ char: 's', description: 'space to get info of' }),
+    json: command_1.flags.boolean({ description: 'output in json format' }),
+    interval: command_1.flags.integer({
+        char: 'i',
+        description: 'seconds to wait between poll intervals',
+        default: 30,
+    }),
+    timeout: command_1.flags.integer({
+        char: 't',
+        description: 'maximum number of seconds to wait',
+        default: 25 * 60,
+    }),
+};
+Wait.args = {
+    space: core_1.Args.string({ hidden: true }),
+};