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

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, description: 'name of space' }),
+    team: command_1.flags.string({ required: true, 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 | 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: {
+        source: import("@oclif/core/lib/interfaces/parser").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}

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({ optional: false, 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 --space my-space vpn-connection-name
+    === 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,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 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 --name office --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 }),
+};

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,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 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({ description: 'name of the VPN connection to destroy', required: true }),
+};

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 --space my-space vpn-connection-name
+    === 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,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const color_1 = require("@heroku-cli/color");
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const 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 office --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 }),
+};

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

@@ -0,0 +1,13 @@
+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, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        name: 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>;
+    };
+    run(): Promise<void>;
+}