heroku 11.0.0-alpha.11 → 11.0.0-alpha.12

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

@@ -0,0 +1,51 @@
+import { color } from '@heroku/heroku-cli-util';
+import { Command, flags } from '@heroku-cli/command';
+import { Args, ux } from '@oclif/core';
+import tsheredoc from 'tsheredoc';
+const heredoc = tsheredoc.default;
+export default class Remove extends Command {
+    static args = {
+        source: Args.string({ description: 'IP address in CIDR notation', required: true }),
+    };
+    static description = heredoc(`
+  Remove a range from the list of trusted IP ranges
+  Uses CIDR notation.`);
+    static examples = [heredoc(`
+    ${color.command('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
+  `)];
+    static flags = {
+        confirm: flags.string({ description: 'set to space name to bypass confirm prompt' }),
+        space: flags.string({ char: 's', description: 'space to remove rule from', required: true }),
+    };
+    static hiddenAliases = ['trusted-ips:remove'];
+    static topic = 'spaces';
+    async run() {
+        const { args, flags } = await this.parse(Remove);
+        const { space } = flags;
+        const url = `/spaces/${space}/inbound-ruleset`;
+        const { body: rules } = await this.heroku.get(url);
+        if (rules.rules?.length === 0) {
+            throw new Error('No IP ranges are configured. Nothing to do.');
+        }
+        const originalLength = rules.rules?.length;
+        rules.rules = rules.rules?.filter(r => r.source !== args.source);
+        if (rules.rules?.length === originalLength) {
+            throw new Error(`No IP range matching ${args.source} was found.`);
+        }
+        await this.heroku.put(url, { body: rules });
+        ux.stdout(`Removed ${color.cyan.bold(args.source)} from trusted IP ranges on ${color.space(space)}`);
+        // Fetch updated ruleset to check applied status
+        const { body: updatedRuleset } = await this.heroku.get(url);
+        // Check applied status to inform users whether rules are effectively applied to the space.
+        // The applied field is optional for backward compatibility with API versions that don't include it yet.
+        // Once the API always includes the applied field (W-19525612), this can be simplified to:
+        //   if (updatedRuleset.applied) { ... } else { ... }
+        if (updatedRuleset.applied === true) {
+            ux.stdout('Trusted IP rules are applied to this space.');
+        }
+        else if (updatedRuleset.applied === false) {
+            ux.stdout('Trusted IP rules are not applied to this space. Update your Trusted IP list to trigger a re-application of the rules.');
+        }
+    }
+}

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 args: {
+        name: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static example: string;
+    static flags: {
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        space: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    static topic: string;
+    run(): Promise<void>;
+}

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

@@ -0,0 +1,53 @@
+import { hux, color } from '@heroku/heroku-cli-util';
+import { Command, flags } from '@heroku-cli/command';
+import { Args } from '@oclif/core';
+import tsheredoc from 'tsheredoc';
+import { displayVPNConfigInfo } from '../../../lib/spaces/vpn-connections.js';
+const heredoc = tsheredoc.default;
+export default class Config extends Command {
+    static args = {
+        name: Args.string({
+            description: 'name or id of the VPN connection to retrieve config from',
+            required: true,
+        }),
+    };
+    static description = heredoc(`
+    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
+  `);
+    static example = heredoc `
+    ${color.command('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
+    `;
+    static flags = {
+        json: flags.boolean({ description: 'output in json format' }),
+        space: flags.string({
+            char: 's',
+            description: 'space the VPN connection belongs to',
+            required: true,
+        }),
+    };
+    static topic = 'spaces';
+    async run() {
+        const { args, flags } = await this.parse(Config);
+        const { json, space } = flags;
+        const { name } = args;
+        const { body: vpnConnection } = await this.heroku.get(`/spaces/${space}/vpn-connections/${name}`);
+        if (json) {
+            hux.styledJSON(vpnConnection);
+        }
+        else {
+            displayVPNConfigInfo(space, name, vpnConnection);
+        }
+    }
+}

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 args: {
+        name: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        cidrs: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        ip: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        space: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    static topic: string;
+    run(): Promise<void>;
+}

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

@@ -0,0 +1,46 @@
+import { color } from '@heroku/heroku-cli-util';
+import { Command, flags } from '@heroku-cli/command';
+import { Args, ux } from '@oclif/core';
+import tsheredoc from 'tsheredoc';
+import { splitCsv } from '../../../lib/spaces/parsers.js';
+const heredoc = tsheredoc.default;
+export default class Connect extends Command {
+    static args = {
+        name: Args.string({
+            description: 'name or id of the VPN connection to create',
+            required: true,
+        }),
+    };
+    static description = heredoc `
+    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.
+  `;
+    static examples = [heredoc(`
+    ${color.command('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.
+  `)];
+    static flags = {
+        cidrs: flags.string({ char: 'c', description: 'a list of routable CIDRs separated by commas', required: true }),
+        ip: flags.string({ char: 'i', description: 'public IP of customer gateway', required: true }),
+        space: flags.string({ char: 's', description: 'space name', required: true }),
+    };
+    static topic = 'spaces';
+    async run() {
+        const { args, flags } = await this.parse(Connect);
+        const { cidrs, ip, space } = flags;
+        const { name } = args;
+        const parsed_cidrs = splitCsv(cidrs);
+        ux.action.start(`Creating VPN Connection in space ${color.space(space)}`);
+        await this.heroku.post(`/spaces/${space}/vpn-connections`, {
+            body: {
+                name,
+                public_ip: ip,
+                routable_cidrs: parsed_cidrs,
+            },
+        });
+        ux.action.stop();
+        ux.warn(`Use ${color.code('heroku spaces:vpn:wait')} to track allocation.`);
+    }
+}

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 description: string;
+    static example: string;
+    static flags: {
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        space: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    static topic: string;
+    protected displayVPNConnections(space: string, connections: Required<Heroku.PrivateSpacesVpn>[]): void;
+    protected render(space: string, connections: Required<Heroku.PrivateSpacesVpn>[], json: boolean): void;
+    run(): Promise<void>;
+    protected tunnelFormat(t: VpnConnectionTunnels): string;
+}
+export {};

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

@@ -0,0 +1,55 @@
+import { color, hux } from '@heroku/heroku-cli-util';
+import { Command, flags } from '@heroku-cli/command';
+import { ux } from '@oclif/core';
+import tsheredoc from 'tsheredoc';
+import { displayVPNStatus } from '../../../lib/spaces/format.js';
+const heredoc = tsheredoc.default;
+export default class Connections extends Command {
+    static description = 'list the VPN Connections for a space';
+    static example = heredoc `
+  ${color.command('heroku spaces:vpn:connections --space my-space')}
+    === my-space VPN Connections
+     Name   Status Tunnels
+     ────── ────── ───────
+     office active UP/UP`;
+    static flags = {
+        json: flags.boolean({ description: 'output in json format' }),
+        space: flags.string({ char: 's', description: 'space to get VPN connections from', required: true }),
+    };
+    static topic = 'spaces';
+    displayVPNConnections(space, connections) {
+        if (connections.length === 0) {
+            ux.stdout('No VPN Connections have been created yet');
+            return;
+        }
+        hux.styledHeader(`${space} VPN Connections`);
+        hux.table(connections, {
+            Name: {
+                get: c => c.name || c.id,
+            },
+            Status: {
+                get: c => displayVPNStatus(c.status),
+            },
+            Tunnels: {
+                get: c => this.tunnelFormat(c.tunnels),
+            },
+        });
+    }
+    render(space, connections, json) {
+        if (json) {
+            hux.styledJSON(connections);
+        }
+        else {
+            this.displayVPNConnections(space, connections);
+        }
+    }
+    async run() {
+        const { flags } = await this.parse(Connections);
+        const { json, space } = flags;
+        const { body: connections } = await this.heroku.get(`/spaces/${space}/vpn-connections`);
+        this.render(space, connections, json);
+    }
+    tunnelFormat(t) {
+        return t.map(tunnel => displayVPNStatus(tunnel.status)).join('/');
+    }
+}

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 args: {
+        name: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        confirm: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        space: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    static topic: string;
+    run(): Promise<void>;
+}

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

@@ -0,0 +1,36 @@
+import { color } from '@heroku/heroku-cli-util';
+import { Command, flags } from '@heroku-cli/command';
+import { Args, ux } from '@oclif/core';
+import tsheredoc from 'tsheredoc';
+import ConfirmCommand from '../../../lib/confirmCommand.js';
+const heredoc = tsheredoc.default;
+export default class Destroy extends Command {
+    static args = {
+        name: Args.string({
+            description: 'name or id of the VPN connection to destroy',
+            required: true,
+        }),
+    };
+    static description = 'destroys VPN in a private space';
+    static examples = [heredoc(`
+    ${color.command('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... done
+  `)];
+    static flags = {
+        confirm: flags.string({ description: 'set to VPN connection name to bypass confirm prompt', hidden: true }),
+        space: flags.string({ char: 's', description: 'space name', required: true }),
+    };
+    static topic = 'spaces';
+    async run() {
+        const { args, flags } = await this.parse(Destroy);
+        const { confirm, space } = flags;
+        const { name } = args;
+        await new ConfirmCommand().confirm(name, confirm, heredoc `
+        Destructive Action
+        This command will attempt to destroy the specified VPN Connection in space ${color.space(space)}
+      `);
+        ux.action.start(`Tearing down VPN Connection ${color.cyan(name)} in space ${color.space(space)}`);
+        await this.heroku.delete(`/spaces/${space}/vpn-connections/${name}`);
+        ux.action.stop();
+    }
+}

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 args: {
+        name: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static example: string;
+    static flags: {
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        space: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    static topic: string;
+    run(): Promise<void>;
+    private displayVPNInfo;
+    private render;
+}

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

@@ -0,0 +1,85 @@
+import { color, hux } from '@heroku/heroku-cli-util';
+import { Command, flags } from '@heroku-cli/command';
+import { Args } from '@oclif/core';
+import tsheredoc from 'tsheredoc';
+import { displayCIDR, displayVPNStatus } from '../../../lib/spaces/format.js';
+const heredoc = tsheredoc.default;
+export default class Info extends Command {
+    static args = {
+        name: Args.string({
+            description: 'name or id of the VPN connection to get info from',
+            required: true,
+        }),
+    };
+    static description = 'display the information for VPN';
+    static example = heredoc `
+    ${color.command('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
+  `;
+    static flags = {
+        json: flags.boolean({ description: 'output in json format' }),
+        space: flags.string({
+            char: 's',
+            description: 'space the vpn connection belongs to',
+            required: true,
+        }),
+    };
+    static topic = 'spaces';
+    async run() {
+        const { args, flags } = await this.parse(Info);
+        const { json, space } = 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) {
+        hux.styledHeader(`${name} VPN Info`);
+        /* eslint-disable perfectionist/sort-objects */
+        hux.styledObject({
+            Name: name,
+            ID: vpnConnection.id,
+            'Public IP': vpnConnection.public_ip,
+            'Routable CIDRs': displayCIDR(vpnConnection.routable_cidrs),
+            Status: `${displayVPNStatus(vpnConnection.status)}`,
+            'Status Message': vpnConnection.status_message,
+        }, ['Name', 'ID', 'Public IP', 'Routable CIDRs', 'State', 'Status', 'Status Message']);
+        /* eslint-enable perfectionist/sort-objects */
+        const vpnConnectionTunnels = vpnConnection.tunnels || [];
+        vpnConnectionTunnels.forEach((val, i) => {
+            val.tunnel_id = 'Tunnel ' + (i + 1);
+        });
+        hux.styledHeader(`${name} VPN Tunnel Info`);
+        /* eslint-disable perfectionist/sort-objects */
+        hux.table(vpnConnectionTunnels, {
+            tunnel_id: { header: 'VPN Tunnel' },
+            ip: { header: 'IP Address' },
+            status: {
+                header: 'Status',
+                get: row => displayVPNStatus(row.status),
+            },
+            last_status_change: { header: 'Status Last Changed' },
+            status_message: { header: 'Details' },
+        });
+        /* eslint-enable perfectionist/sort-objects */
+    }
+    render(name, vpnConnection, json) {
+        if (json) {
+            hux.styledJSON(vpnConnection);
+        }
+        else {
+            this.displayVPNInfo(name, vpnConnection);
+        }
+    }
+}

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 args: {
+        name: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static example: string;
+    static flags: {
+        cidrs: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        space: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    static topic: string;
+    run(): Promise<void>;
+}

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

@@ -0,0 +1,36 @@
+import { color } from '@heroku/heroku-cli-util';
+import { Command, flags } from '@heroku-cli/command';
+import { Args, ux } from '@oclif/core';
+import tsheredoc from 'tsheredoc';
+import { splitCsv } from '../../../lib/spaces/parsers.js';
+const heredoc = tsheredoc.default;
+export default class Update extends Command {
+    static args = {
+        name: Args.string({
+            description: 'name or id of the VPN connection to update',
+            required: true,
+        }),
+    };
+    static description = heredoc `
+    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.
+  `;
+    static example = heredoc `
+    ${color.command('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`;
+    static flags = {
+        cidrs: flags.string({ char: 'c', description: 'a list of routable CIDRs separated by commas', required: true }),
+        space: flags.string({ char: 's', description: 'space name', required: true }),
+    };
+    static topic = 'spaces';
+    async run() {
+        const { args, flags } = await this.parse(Update);
+        const { cidrs, space } = flags;
+        const { name } = args;
+        const parsedCidrs = splitCsv(cidrs);
+        ux.action.start(`Updating VPN Connection in space ${color.space(space)}`);
+        await this.heroku.patch(`/spaces/${space}/vpn-connections/${name}`, { body: { routable_cidrs: parsedCidrs } });
+        ux.action.stop();
+    }
+}

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/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        interval: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        timeout: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    static args: {
+        name: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}

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

@@ -0,0 +1,69 @@
+import { color } from '@heroku/heroku-cli-util';
+import { Command, flags } from '@heroku-cli/command';
+import { Args, ux } from '@oclif/core';
+import { hux } from '@heroku/heroku-cli-util';
+import { displayVPNConfigInfo } from '../../../lib/spaces/vpn-connections.js';
+import tsheredoc from 'tsheredoc';
+const heredoc = tsheredoc.default;
+const wait = (ms) => new Promise(resolve => {
+    setTimeout(resolve, ms);
+});
+export default class Wait extends Command {
+    static topic = 'spaces';
+    static description = 'wait for VPN Connection to be created';
+    static examples = [heredoc(`
+    ${color.command('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
+    `)];
+    static flags = {
+        space: flags.string({ char: 's', description: 'space the vpn connection belongs to', required: true }),
+        json: flags.boolean({ description: 'output in json format' }),
+        interval: flags.string({ char: 'i', description: 'seconds to wait between poll intervals' }),
+        timeout: flags.string({ char: 't', description: 'maximum number of seconds to wait' }),
+    };
+    static args = {
+        name: Args.string({
+            description: 'name or id of the VPN connection you are waiting on for allocation.',
+            required: true,
+        }),
+    };
+    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') {
+            ux.stdout('VPN has been allocated.');
+            return;
+        }
+        ux.action.start(`Waiting for VPN Connection ${color.green(name)} to allocate...`);
+        while (vpnConnection.status !== 'active') {
+            if (new Date() > deadline) {
+                ux.error('Timeout waiting for VPN to become allocated.', { exit: 1 });
+            }
+            if (vpnConnection.status === 'failed') {
+                ux.error(vpnConnection.status_message || '', { exit: 1 });
+            }
+            await wait(interval);
+            const { body: updatedVpnConnection } = await this.heroku.get(`/spaces/${space}/vpn-connections/${name}`);
+            vpnConnection = updatedVpnConnection;
+        }
+        ux.action.stop();
+        const { body: newVpnConnection } = await this.heroku.get(`/spaces/${space}/vpn-connections/${name}`);
+        if (json) {
+            hux.styledJSON(newVpnConnection);
+        }
+        else {
+            displayVPNConfigInfo(space, name, newVpnConnection);
+        }
+    }
+}

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

@@ -0,0 +1,17 @@
+import { Command } from '@heroku-cli/command';
+export default class Wait extends Command {
+    static args: {
+        space: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static flags: {
+        interval: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        space: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        timeout: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    static topic: string;
+    protected notify(spaceName: string): void;
+    run(): Promise<void>;
+    protected wait(ms: number): Promise<unknown>;
+}

package/lib/commands/spaces/wait.js

@@ -0,0 +1,87 @@
+import { color } from '@heroku/heroku-cli-util';
+import { Command, flags } from '@heroku-cli/command';
+import { notify } from '@heroku-cli/notifications';
+import { Args, ux } from '@oclif/core';
+import debug from 'debug';
+import tsheredoc from 'tsheredoc';
+import { renderInfo } from '../../lib/spaces/spaces.js';
+const heredoc = tsheredoc.default;
+const spacesDebug = debug('spaces:wait');
+export default class Wait extends Command {
+    static args = {
+        space: Args.string({ hidden: true }),
+    };
+    static description = 'wait for a space to be created';
+    static flags = {
+        interval: flags.integer({
+            char: 'i',
+            default: 30,
+            description: 'seconds to wait between poll intervals',
+        }),
+        json: flags.boolean({ description: 'output in json format' }),
+        space: flags.string({ char: 's', description: 'space to get info of' }),
+        timeout: flags.integer({
+            char: 't',
+            default: 25 * 60,
+            description: 'maximum number of seconds to wait',
+        }),
+    };
+    static topic = 'spaces';
+    notify(spaceName) {
+        try {
+            const notification = {
+                message: 'space was successfully created',
+                sound: true,
+                subtitle: `heroku spaces:wait ${spaceName}`,
+                title: spaceName,
+            };
+            notify(notification);
+        }
+        catch (error) {
+            ux.warn(error);
+        }
+    }
+    async run() {
+        const { args, flags } = await this.parse(Wait);
+        const spaceName = flags.space || args.space;
+        if (!spaceName) {
+            ux.error(heredoc(`
+        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);
+        ux.action.start(`Waiting for space ${color.space(spaceName)} to allocate`);
+        const headers = {
+            Accept: 'application/vnd.heroku+json; version=3.fir',
+        };
+        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`, { headers: { Accept: 'application/vnd.heroku+json; version=3.fir' } });
+            space.outbound_ips = nat;
+        }
+        catch (error) {
+            spacesDebug(`Retrieving NAT details for the space failed with ${error}`);
+        }
+        ux.action.stop();
+        renderInfo(space, flags.json);
+        this.notify(spaceName);
+    }
+    wait(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+}