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

package/lib/commands/run/inside.js

@@ -0,0 +1,77 @@
+import { color } from '@heroku/heroku-cli-util';
+import { Command, flags } from '@heroku-cli/command';
+import { Args, ux } from '@oclif/core';
+import debugFactory from 'debug';
+import tsheredoc from 'tsheredoc';
+import Dyno from '../../lib/run/dyno.js';
+import { buildCommandWithLauncher } from '../../lib/run/helpers.js';
+const debug = debugFactory('heroku:run:inside');
+const heredoc = tsheredoc.default;
+export default class RunInside extends Command {
+    static args = {
+        command: Args.string({
+            description: 'command to run (Heroku automatically prepends \'launcher\' to the command)',
+            required: true,
+        }),
+        dyno_name: Args.string({
+            description: 'name of the dyno to run command inside',
+            required: true,
+        }),
+    };
+    static description = 'run a command inside an existing dyno (for Fir-generation apps only)';
+    static examples = [
+        heredoc `
+      # Run bash
+      ${color.command('heroku run:inside web-848cd4f64d-pvpr2 bash -a my-app')}
+    `,
+        heredoc `
+      # Run a command supplied by a script taking option flags
+      ${color.command('heroku run:inside web-848cd4f64d-pvpr2 -a my-app -- myscript.sh -x --log-level=warn')}
+    `,
+        heredoc `
+      # Run a command declared for the worker process type in a Procfile
+      ${color.command('heroku run:inside web-848cd4f64d-pvpr2 worker -a my-app')}
+    `,
+    ];
+    static flags = {
+        app: flags.app({ required: true }),
+        'exit-code': flags.boolean({
+            char: 'x',
+            description: 'passthrough the exit code of the remote command',
+        }),
+        listen: flags.boolean({ description: 'listen on a local port', hidden: true }),
+        'no-launcher': flags.boolean({
+            default: false,
+            description: 'don\'t prepend \'launcher\' before a command',
+        }),
+        remote: flags.remote(),
+    };
+    static strict = false;
+    async run() {
+        const { args, argv, flags } = await this.parse(RunInside);
+        const { dyno_name: dynoName } = args;
+        const { app: appName, 'exit-code': exitCode, listen, 'no-launcher': noLauncher } = flags;
+        const opts = {
+            app: appName,
+            command: await buildCommandWithLauncher(this.heroku, appName, argv.slice(1), noLauncher),
+            dyno: dynoName,
+            'exit-code': exitCode,
+            heroku: this.heroku,
+            listen,
+        };
+        const dyno = new Dyno(opts);
+        try {
+            await dyno.start();
+        }
+        catch (error) {
+            debug(error);
+            const err = error;
+            if (err.exitCode) {
+                ux.exit(err.exitCode);
+            }
+            else {
+                throw error;
+            }
+        }
+    }
+}

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

@@ -1,8 +1,8 @@
 import { Command } from '@heroku-cli/command';
 export default class SessionsDestroy extends Command {
-    static description: string;
     static args: {
         id: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
     };
+    static description: string;
     run(): Promise<void>;
 }

package/lib/commands/sessions/destroy.js

@@ -1,14 +1,14 @@
-import { color } from '@heroku-cli/color';
+import { color } from '@heroku/heroku-cli-util';
 import { Command } from '@heroku-cli/command';
 import { Args, ux } from '@oclif/core';
 export default class SessionsDestroy extends Command {
-    static description = 'delete (logout) OAuth session by ID';
     static args = {
-        id: Args.string({ required: true, description: 'ID of the OAuth session' }),
+        id: Args.string({ description: 'ID of the OAuth session', required: true }),
     };
+    static description = 'delete (logout) OAuth session by ID';
     async run() {
         const { args: { id } } = await this.parse(SessionsDestroy);
-        ux.action.start(`Destroying ${color.cyan(id)}`);
+        ux.action.start(`Destroying ${color.name(id)}`);
         await this.heroku.delete(`/oauth/sessions/${encodeURIComponent(id)}`);
         ux.action.stop();
     }

package/lib/commands/sessions/index.js

@@ -1,7 +1,6 @@
-import { color } from '@heroku-cli/color';
+import { color, hux } from '@heroku/heroku-cli-util';
 import { Command, flags } from '@heroku-cli/command';
 import { ux } from '@oclif/core';
-import { hux } from '@heroku/heroku-cli-util';
 export default class SessionsIndex extends Command {
     static description = 'list your OAuth sessions';
     static flags = {
@@ -24,7 +23,7 @@ export default class SessionsIndex extends Command {
         else {
             hux.table(sessions, {
                 description: {
-                    get: (v) => color.green(v.description),
+                    get: (v) => color.info(v.description),
                     header: 'Description',
                 },
                 id: {

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

@@ -0,0 +1,23 @@
+import { Command } from '@heroku-cli/command';
+export default class Create extends Command {
+    static args: {
+        space: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        channel: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        cidr: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'data-cidr': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        features: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        generation: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        'kpi-url': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'log-drain-url': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        region: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        shield: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        space: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        team: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    static topic: string;
+    run(): Promise<void>;
+}

package/lib/commands/spaces/create.js

@@ -0,0 +1,87 @@
+import { color, hux } from '@heroku/heroku-cli-util';
+import { Command, flags } from '@heroku-cli/command';
+import { RegionCompletion } from '@heroku-cli/command/lib/completions.js';
+import { Args, ux } from '@oclif/core';
+import tsheredoc from 'tsheredoc';
+import { getGeneration } from '../../lib/apps/generation.js';
+import { splitCsv } from '../../lib/spaces/parsers.js';
+import { displayShieldState } from '../../lib/spaces/spaces.js';
+const heredoc = tsheredoc.default;
+export default class Create extends Command {
+    static args = {
+        space: Args.string({ hidden: true }),
+    };
+    static description = heredoc `
+    create a new space
+  `;
+    static examples = [heredoc `
+    Example:
+
+    ${color.command('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
+    Generation: cedar
+    Created at: 2016-01-06T03:23:13Z
+  `];
+    static flags = {
+        channel: flags.string({ hidden: true }),
+        cidr: flags.string({ description: 'RFC-1918 CIDR the space will use' }),
+        'data-cidr': flags.string({ description: 'RFC-1918 CIDR used by Heroku Data resources for the space' }),
+        features: flags.string({ description: 'a list of features separated by commas', hidden: true }),
+        generation: flags.string({ default: 'cedar', description: 'generation for space', options: ['cedar', 'fir'] }),
+        'kpi-url': flags.string({ description: 'self-managed KPI endpoint to use', hidden: true }),
+        'log-drain-url': flags.string({ description: 'direct log drain url', hidden: true }),
+        region: flags.string({ completion: RegionCompletion, description: 'region name' }),
+        shield: flags.boolean({ description: 'create a Shield space', hidden: true }),
+        space: flags.string({ char: 's', description: 'name of space to create' }),
+        team: flags.team({ required: true }),
+    };
+    static topic = 'spaces';
+    async run() {
+        const { args, flags } = await this.parse(Create);
+        const { channel, cidr, 'data-cidr': dataCidr, features, generation, 'kpi-url': kpiUrl, 'log-drain-url': logDrainUrl, region, shield, team } = flags;
+        const spaceName = flags.space || args.space;
+        if (!spaceName) {
+            ux.error(heredoc `
+        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';
+        ux.action.start(`Creating space ${color.space(spaceName)} in team ${color.cyan(team)}`);
+        const { body: space } = await this.heroku.post('/spaces', {
+            body: {
+                channel_name: channel,
+                cidr,
+                data_cidr: dataCidr,
+                features: splitCsv(features),
+                generation,
+                kpi_url: kpiUrl,
+                log_drain_url: logDrainUrl,
+                name: spaceName,
+                region,
+                shield,
+                team,
+            },
+            headers: {
+                Accept: 'application/vnd.heroku+json; version=3.sdk',
+            },
+        });
+        ux.action.stop();
+        ux.warn(`${color.warning('Spend Alert.')} Each Heroku ${spaceType} Private Space costs ~${dollarAmountHourly}/hour (max ${dollarAmountMonthly}/month), pro-rated to the second.`);
+        ux.warn(`Use ${color.code('heroku spaces:wait')} to track allocation.`);
+        hux.styledHeader(color.space(space.name));
+        hux.styledObject({
+            // eslint-disable-next-line perfectionist/sort-objects
+            ID: space.id, Team: color.team(space.team.name || ''), Region: space.region.name, CIDR: space.cidr, 'Data CIDR': space.data_cidr, State: space.state, Shield: displayShieldState(space), Generation: getGeneration(space), 'Created at': space.created_at,
+        }, ['ID', 'Team', 'Region', 'CIDR', 'Data CIDR', 'State', 'Shield', 'Generation', 'Created at']);
+    }
+}

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

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

package/lib/commands/spaces/destroy.js

@@ -0,0 +1,61 @@
+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 { getGeneration } from '../../lib/apps/generation.js';
+import ConfirmCommand from '../../lib/confirmCommand.js';
+import { displayNat } from '../../lib/spaces/spaces.js';
+const heredoc = tsheredoc.default;
+export default class Destroy extends Command {
+    static args = {
+        space: Args.string({ hidden: true }),
+    };
+    static description = heredoc `
+    destroy a space
+  `;
+    static examples = [heredoc `
+    ${color.command('heroku spaces:destroy --space my-space')}
+    Destroying my-space... done
+  `];
+    static flags = {
+        confirm: flags.string({ description: 'set to space name to bypass confirm prompt', hasValue: true }),
+        space: flags.string({ char: 's', description: 'space to destroy' }),
+    };
+    static topic = 'spaces';
+    async run() {
+        const { args, flags } = await this.parse(Destroy);
+        const { confirm } = flags;
+        const spaceName = flags.space || args.space;
+        if (!spaceName) {
+            ux.error(heredoc `
+        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') {
+                const ipv6 = getGeneration(space) === 'fir' ? ' and IPv6' : '';
+                natWarning = heredoc `
+        ${color.dim('===')} ${color.label('WARNING: Outbound IPs Will Be Reused')}
+        ${color.warning(`⚠️ Deleting this space frees up the following outbound IPv4${ipv6} IPs for reuse:`)}
+        ${color.label(displayNat(space.outbound_ips) ?? '')}
+
+        ${color.dim('Update the following configurations:')}
+        ${color.dim('=')} IP allowlists
+        ${color.dim('=')} Firewall rules
+        ${color.dim('=')} Security group configurations
+        ${color.dim('=')} Network ACLs
+
+        ${color.warning(`Ensure that you remove the listed IPv4${ipv6} addresses from your security configurations.`)}
+      `;
+            }
+        }
+        await new ConfirmCommand().confirm(spaceName, confirm, `Destructive Action\nThis command will destroy the space ${color.space(spaceName)}\n${natWarning}\n`);
+        ux.action.start(`Destroying space ${color.space(spaceName)}`);
+        await this.heroku.delete(`/spaces/${spaceName}`);
+        ux.action.stop();
+    }
+}

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

@@ -0,0 +1,11 @@
+import { Command } from '@heroku-cli/command';
+export default class Get extends Command {
+    static aliases: string[];
+    static description: 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/drains/get.js

@@ -0,0 +1,23 @@
+import { color } from '@heroku/heroku-cli-util';
+import { Command, flags } from '@heroku-cli/command';
+import { ux } from '@oclif/core';
+export default class Get extends Command {
+    static aliases = ['drains:get'];
+    static description = 'display the log drain for a space';
+    static flags = {
+        json: flags.boolean({ description: 'output in json format' }),
+        space: flags.string({ char: 's', description: 'space for which to get log drain', required: true }),
+    };
+    static topic = 'spaces';
+    async run() {
+        const { flags } = await this.parse(Get);
+        const { json, space } = flags;
+        const { body: drain } = await this.heroku.get(`/spaces/${space}/log-drain`, { headers: { Accept: 'application/vnd.heroku+json; version=3.dogwood' } });
+        if (json) {
+            ux.stdout(JSON.stringify(drain, null, 2));
+        }
+        else {
+            ux.stdout(`${color.info(drain.url)} (${color.name(drain.token)})`);
+        }
+    }
+}

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

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

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

@@ -0,0 +1,25 @@
+import { color } from '@heroku/heroku-cli-util';
+import { Command, flags } from '@heroku-cli/command';
+import { Args, ux } from '@oclif/core';
+export default class Set extends Command {
+    static aliases = ['drains:set'];
+    static args = {
+        url: Args.string({ description: 'URL to replace the log drain with', required: true }),
+    };
+    static description = 'replaces the log drain for a space';
+    static flags = {
+        space: flags.string({ char: 's', description: 'space for which to set log drain', required: true }),
+    };
+    static topic = 'spaces';
+    async run() {
+        const { args, flags } = 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' },
+        });
+        ux.stdout(`Successfully set drain ${color.cyan(drain.url)} for ${color.space(space)}.`);
+        ux.warn('It may take a few moments for the changes to take effect.');
+    }
+}

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

package/lib/commands/spaces/hosts.js

@@ -0,0 +1,35 @@
+import { Command, flags } from '@heroku-cli/command';
+import { Args, ux } from '@oclif/core';
+import tsheredoc from 'tsheredoc';
+import { displayHostsAsJSON, displayHosts } from '../../lib/spaces/hosts.js';
+const heredoc = tsheredoc.default;
+export default class Hosts extends Command {
+    static topic = 'spaces';
+    static hidden = true;
+    static description = 'list dedicated hosts for a space';
+    static flags = {
+        space: flags.string({ char: 's', description: 'space to get host list from' }),
+        json: flags.boolean({ description: 'output in json format' }),
+    };
+    static args = {
+        space: Args.string({ hidden: true }),
+    };
+    async run() {
+        const { flags, args } = await this.parse(Hosts);
+        const spaceName = flags.space || args.space;
+        if (!spaceName) {
+            ux.error(heredoc(`
+        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)
+            displayHostsAsJSON(hosts);
+        else
+            displayHosts(spaceName, hosts);
+    }
+}

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

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

package/lib/commands/spaces/index.js

@@ -0,0 +1,65 @@
+/* eslint-disable perfectionist/sort-objects */
+import { color, hux } from '@heroku/heroku-cli-util';
+import { Command, flags as Flags } from '@heroku-cli/command';
+import { ux } from '@oclif/core';
+import { getGeneration } from '../../lib/apps/generation.js';
+export default class Index extends Command {
+    static description = 'list available spaces';
+    static flags = {
+        json: Flags.boolean({ description: 'output in json format' }),
+        team: Flags.team(),
+    };
+    static topic = 'spaces';
+    display(spaces) {
+        hux.table(spaces, {
+            Name: { get: space => color.space(space.name) },
+            Team: { get: space => color.team(space.team.name || '') },
+            Region: { get: space => space.region.name },
+            State: {
+                get(space) {
+                    if (space.state === 'allocated')
+                        return color.success(space.state);
+                    if (space.state === 'deleting')
+                        return color.failure(space.state);
+                    return color.warning(space.state);
+                },
+            },
+            Generation: { get: space => getGeneration(space) },
+            createdAt: {
+                header: 'Created At',
+                get: space => space.created_at,
+            },
+        });
+    }
+    displayJSON(spaces) {
+        ux.stdout(JSON.stringify(spaces, null, 2));
+    }
+    async run() {
+        const { flags } = await this.parse(Index);
+        const { json, team } = flags;
+        let { body: spaces } = await this.heroku.get('/spaces', {
+            headers: {
+                Accept: 'application/vnd.heroku+json; version=3.sdk',
+            },
+        });
+        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)
+                ux.error(`No spaces in ${color.team(team)}.`);
+            else
+                ux.error('You do not have access to any spaces.');
+        }
+        else {
+            this.display(spaces);
+        }
+    }
+    sortByName(spaces) {
+        spaces.sort((a, b) => a.name === b.name ? 0 : (a.name < b.name ? -1 : 1));
+        return spaces;
+    }
+}

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

@@ -0,0 +1,14 @@
+import { Command } from '@heroku-cli/command';
+export default class Info extends Command {
+    static args: {
+        space: import("@oclif/core/interfaces").Arg<string | undefined, 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 | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    static topic: string;
+    run(): Promise<void>;
+}

package/lib/commands/spaces/info.js

@@ -0,0 +1,48 @@
+import { color } from '@heroku/heroku-cli-util';
+import { Command, flags } from '@heroku-cli/command';
+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:info');
+export default class Info extends Command {
+    static args = {
+        space: Args.string({ hidden: true }),
+    };
+    static description = 'show info about a space';
+    static example = `${color.command('heroku spaces:info my-space')}`;
+    static flags = {
+        json: flags.boolean({ description: 'output in json format' }),
+        space: flags.string({ char: 's', description: 'space to get info of' }),
+    };
+    static topic = 'spaces';
+    async run() {
+        const { args, flags } = await this.parse(Info);
+        const spaceName = flags.space || args.space;
+        if (!spaceName) {
+            ux.error(heredoc(`
+        Error: Missing 1 required arg:
+        space
+        See more help with --help
+      `));
+        }
+        const headers = {
+            Accept: 'application/vnd.heroku+json; version=3.fir',
+        };
+        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`, { headers: { Accept: 'application/vnd.heroku+json; version=3.fir' } });
+                space.outbound_ips = outbound_ips;
+            }
+            catch (error) {
+                spacesDebug(`Retrieving NAT details for the space failed with ${error}`);
+            }
+        }
+        renderInfo(space, flags.json);
+    }
+}

package/lib/commands/spaces/peerings/accept.d.ts

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

package/lib/commands/spaces/peerings/accept.js

@@ -0,0 +1,33 @@
+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 Accept extends Command {
+    static args = {
+        pcxid: Args.string({ hidden: true }),
+        space: Args.string({ hidden: true }),
+    };
+    static description = 'accepts a pending peering request for a private space';
+    static examples = [heredoc(`
+${color.command('heroku spaces:peerings:accept pcx-4bd27022 --space example-space')}
+Accepting and configuring peering connection pcx-4bd27022`)];
+    static flags = {
+        pcxid: flags.string({ char: 'p', description: 'PCX ID of a pending peering' }),
+        space: flags.string({ char: 's', description: 'space to get peering info from' }),
+    };
+    static topic = 'spaces';
+    async run() {
+        const { args, flags } = await this.parse(Accept);
+        const space = flags.space || args.space;
+        if (!space) {
+            throw new Error('Space name required.\nUSAGE: heroku spaces:peerings:accept pcx-12345678 --space my-space');
+        }
+        const pcxID = flags.pcxid || args.pcxid;
+        await this.heroku.post(`/spaces/${space}/peerings`, {
+            body: { pcx_id: pcxID },
+            headers: { Accept: 'application/vnd.heroku+json; version=3.dogwood' },
+        });
+        ux.stdout(`Accepting and configuring peering connection ${color.cyan.bold(pcxID)}`);
+    }
+}