heroku 11.0.0-alpha.11 → 11.0.0-alpha.13

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

@@ -0,0 +1,15 @@
+import { Command } from '@heroku-cli/command';
+export default class Destroy extends Command {
+    static args: {
+        pcxid: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static example: string;
+    static flags: {
+        confirm: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        pcxid: 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/peerings/destroy.js

@@ -0,0 +1,43 @@
+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 = {
+        pcxid: Args.string({ hidden: true }),
+    };
+    static description = 'destroys an active peering connection in a private space';
+    static example = heredoc `
+    ${color.command('heroku spaces:peerings:destroy pcx-4bd27022 --confirm pcx-4bd27022 --space example-space')}
+    Tearing down peering connection pcx-4bd27022... done
+  `;
+    static flags = {
+        confirm: flags.string({ description: 'set to PCX ID to bypass confirm prompt' }),
+        pcxid: flags.string({ char: 'p', description: 'PCX ID of a pending peering' }),
+        space: flags.string({
+            char: 's',
+            description: 'space to get peering info from',
+            required: true,
+        }),
+    };
+    static topic = 'spaces';
+    async run() {
+        const { args, flags } = await this.parse(Destroy);
+        const pcxID = flags.pcxid || args.pcxid;
+        if (!pcxID) {
+            ux.error(heredoc `
+        pcxid required.
+        USAGE: heroku spaces:peering:destroy pcx-4bd27022
+      `);
+        }
+        await new ConfirmCommand().confirm(pcxID, flags.confirm, heredoc(`
+      Destructive Action
+      This command will attempt to destroy the peering connection ${color.warning(pcxID)}
+    `));
+        ux.action.start(`Tearing down peering connection ${color.name(pcxID)}`);
+        await this.heroku.delete(`/spaces/${flags.space}/peerings/${pcxID}`);
+        ux.action.stop();
+    }
+}

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

@@ -0,0 +1,13 @@
+import { Command } from '@heroku-cli/command';
+export default class Index extends Command {
+    static topic: string;
+    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/peerings/index.js

@@ -0,0 +1,31 @@
+import { Command, flags } from '@heroku-cli/command';
+import { Args, ux } from '@oclif/core';
+import { displayPeerings, displayPeeringsAsJSON } from '../../../lib/spaces/peering.js';
+import tsheredoc from 'tsheredoc';
+const heredoc = tsheredoc.default;
+export default class Index extends Command {
+    static topic = 'spaces';
+    static description = 'list peering connections for a space';
+    static flags = {
+        space: flags.string({ char: 's', description: 'space to get peer 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(Index);
+        const spaceName = flags.space || args.space;
+        if (!spaceName) {
+            ux.error(heredoc `
+          space required.
+          USAGE: heroku spaces:peerings my-space
+        `);
+        }
+        const { body: peerings } = await this.heroku.get(`/spaces/${spaceName}/peerings`);
+        if (flags.json)
+            displayPeeringsAsJSON(peerings);
+        else
+            displayPeerings(spaceName, peerings);
+    }
+}

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

@@ -0,0 +1,15 @@
+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 examples: string[];
+    static flags: {
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        space: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    static hiddenAliases: string[];
+    static topic: string;
+    run(): Promise<void>;
+}

package/lib/{oldCommands → commands}/spaces/peerings/info.js

@@ -1,15 +1,14 @@
-export {};
-/*
-import {Command, flags} from '@heroku-cli/command'
-import {Args, ux} from '@oclif/core'
-import * as Heroku from '@heroku-cli/schema'
-import heredoc from 'tsheredoc'
-import {displayPeeringInfo} from '../../../lib/spaces/peering'
-
+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 { displayPeeringInfo } from '../../../lib/spaces/peering.js';
+const heredoc = tsheredoc.default;
 export default class Info extends Command {
-  static topic = 'spaces'
-  static hiddenAliases = ['spaces:peering:info']
-  static description = heredoc(`
+    static args = {
+        space: Args.string({ hidden: true }),
+    };
+    static description = heredoc(`
     display the information necessary to initiate a peering connection
 
     You will use the information provided by this command to establish a peering connection request from your AWS VPC to your private space.
@@ -22,15 +21,9 @@ export default class Info extends Command {
 
     Once you've established the peering connection request, you can use the spaces:peerings:accept command to accept and
     configure the peering connection for the space.
-  `)
-
-  static flags = {
-    space: flags.string({char: 's', description: 'space to get peering info from'}),
-    json: flags.boolean({description: 'output in json format'}),
-  }
-
-  static examples = [heredoc(`
-    $ heroku spaces:peering:info example-space
+  `);
+    static examples = [heredoc(`
+    ${color.command('heroku spaces:peering:info example-space')}
     === example-space  Peering Info
 
     AWS Account ID:    012345678910
@@ -39,28 +32,27 @@ export default class Info extends Command {
     AWS VPC CIDR:      10.0.0.0/16
     Space CIDRs:       10.0.128.0/20, 10.0.144.0/20
     Unavailable CIDRs: 10.1.0.0/16
-  `)]
-
-  static args = {
-    space: Args.string({hidden: true}),
-  }
-
-  public async run(): Promise<void> {
-    const {flags, args} = await this.parse(Info)
-    const spaceName = flags.space || args.space
-    if (!spaceName) {
-      ux.error(heredoc(`
+  `)];
+    static flags = {
+        json: flags.boolean({ description: 'output in json format' }),
+        space: flags.string({ char: 's', description: 'space to get peering info from' }),
+    };
+    static hiddenAliases = ['spaces:peering:info'];
+    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 { body: pInfo } = await this.heroku.get(`/spaces/${spaceName}/peering-info`);
+        if (flags.json)
+            ux.stdout(JSON.stringify(pInfo, null, 2));
+        else
+            displayPeeringInfo(spaceName, pInfo);
     }
-
-    const {body: pInfo} = await this.heroku.get<Heroku.PeeringInfo>(`/spaces/${spaceName}/peering-info`)
-    if (flags.json)
-      ux.log(JSON.stringify(pInfo, null, 2))
-    else
-      displayPeeringInfo(spaceName as string, pInfo)
-  }
 }
-*/

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

@@ -0,0 +1,15 @@
+import { Command } from '@heroku-cli/command';
+export default class Ps extends Command {
+    static args: {
+        space: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: 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>;
+    private printDynos;
+    private render;
+}

package/lib/commands/spaces/ps.js

@@ -0,0 +1,77 @@
+import { color, hux } from '@heroku/heroku-cli-util';
+import { Command, flags } from '@heroku-cli/command';
+import { Args, ux } from '@oclif/core';
+import { ago } from '../../lib/time.js';
+const getProcessNum = (s) => Number.parseInt(s.split('.', 2)[1], 10);
+export default class Ps extends Command {
+    static args = {
+        space: Args.string({ hidden: true }),
+    };
+    static description = 'list dynos for a space';
+    static flags = {
+        json: flags.boolean({ description: 'output in json format' }),
+        space: flags.string({ char: 's', description: 'space to get dynos of' }),
+    };
+    static topic = 'spaces';
+    async run() {
+        const { args, flags } = await this.parse(Ps);
+        const spaceName = flags.space || args.space;
+        if (!spaceName) {
+            throw new Error('Space name required.\nUSAGE: heroku spaces:ps my-space');
+        }
+        const [{ body: spaceDynos }, { body: space }] = await Promise.all([
+            this.heroku.get(`/spaces/${spaceName}/dynos`),
+            this.heroku.get(`/spaces/${spaceName}`),
+        ]);
+        if (space.shield) {
+            spaceDynos.forEach(spaceDyno => {
+                spaceDyno.dynos.forEach(d => {
+                    if (d.size?.startsWith('Private')) {
+                        d.size = d.size.replace('Private-', 'Shield-');
+                    }
+                });
+            });
+        }
+        if (flags.json) {
+            hux.styledJSON(spaceDynos);
+        }
+        else {
+            this.render(spaceDynos);
+        }
+    }
+    printDynos(appName, dynos) {
+        const dynosByCommand = new Map();
+        for (const dyno of dynos) {
+            const since = ago(new Date(dyno.updated_at));
+            const size = dyno.size ?? '1X';
+            let key = '';
+            let item = '';
+            if (dyno.type === 'run') {
+                key = 'run: one-off processes';
+                item = `${dyno.name} (${size}): ${dyno.state} ${since}: ${dyno.command}`;
+            }
+            else {
+                key = `${color.name(dyno.type)} (${color.info(size)}): ${dyno.command}`;
+                const state = dyno.state === 'up' ? color.success(dyno.state) : color.warning(dyno.state);
+                item = `${dyno.name}: ${color.info(state)} ${color.dim(since)}`;
+            }
+            if (!dynosByCommand.has(key)) {
+                dynosByCommand.set(key, []);
+            }
+            dynosByCommand.get(key)?.push(item);
+        }
+        for (const [key, dynos] of dynosByCommand) {
+            hux.styledHeader(`${appName} ${key} (${color.info(dynos.length.toString())})`);
+            dynos.sort((a, b) => getProcessNum(a) - getProcessNum(b));
+            for (const dyno of dynos) {
+                ux.stdout(dyno);
+            }
+            ux.stdout();
+        }
+    }
+    render(spaceDynos) {
+        spaceDynos?.forEach(spaceDyno => {
+            this.printDynos(spaceDyno.app_name, spaceDyno.dynos);
+        });
+    }
+}

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

@@ -0,0 +1,11 @@
+import { Command } from '@heroku-cli/command';
+export default class Rename extends Command {
+    static description: string;
+    static example: string;
+    static flags: {
+        from: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        to: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    static topic: string;
+    run(): Promise<void>;
+}

package/lib/commands/spaces/rename.js

@@ -0,0 +1,24 @@
+import { color } from '@heroku/heroku-cli-util';
+import { Command, flags } from '@heroku-cli/command';
+import { ux } from '@oclif/core';
+import tsheredoc from 'tsheredoc';
+const heredoc = tsheredoc.default;
+export default class Rename extends Command {
+    static description = 'renames a space';
+    static example = heredoc `
+    ${color.command('heroku spaces:rename --from old-space-name --to new-space-name')}
+    Renaming space old-space-name to new-space-name... done
+  `;
+    static flags = {
+        from: flags.string({ description: 'current name of space', required: true }),
+        to: flags.string({ description: 'desired name of space', required: true }),
+    };
+    static topic = 'spaces';
+    async run() {
+        const { flags } = await this.parse(Rename);
+        const { from, to } = flags;
+        ux.action.start(`Renaming space from ${color.space(from)} to ${color.info(to)}`);
+        await this.heroku.patch(`/spaces/${from}`, { body: { name: to } });
+        ux.action.stop();
+    }
+}

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

@@ -0,0 +1,18 @@
+import { Command } from '@heroku-cli/command';
+import * as Heroku from '@heroku-cli/schema';
+import { SpaceTopology } from '../../lib/types/spaces.js';
+export default class Topology extends Command {
+    static args: {
+        space: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: 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;
+    protected getProcessNum(s: string): number;
+    protected getProcessType(s: string): string;
+    protected render(topology: SpaceTopology, appInfo: Heroku.App[], json: boolean): void;
+    run(): Promise<void>;
+}

package/lib/commands/spaces/topology.js

@@ -0,0 +1,87 @@
+import { color, hux } 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 Topology extends Command {
+    static args = {
+        space: Args.string({ hidden: true }),
+    };
+    static description = 'show space topology';
+    static flags = {
+        json: flags.boolean({ description: 'output in json format' }),
+        space: flags.string({ char: 's', description: 'space to get topology of' }),
+    };
+    static topic = 'spaces';
+    getProcessNum(s) {
+        return Number.parseInt(s.split('-', 2)[0].split('.', 2)[1], 10);
+    }
+    getProcessType(s) {
+        return s.split('-', 2)[0].split('.', 2)[0];
+    }
+    render(topology, appInfo, json) {
+        if (json) {
+            hux.styledJSON(topology);
+        }
+        else if (topology.apps) {
+            topology.apps.forEach(app => {
+                const formations = [];
+                const dynos = [];
+                if (app.formations) {
+                    app.formations.forEach(formation => {
+                        formations.push(formation.process_type);
+                        if (formation.dynos) {
+                            formation.dynos.forEach(dyno => {
+                                const dynoS = [`${formation.process_type}.${dyno.number}`, dyno.private_ip, dyno.hostname].filter(Boolean);
+                                dynos.push(dynoS.join(' - '));
+                            });
+                        }
+                    });
+                }
+                const domains = app.domains.sort();
+                formations.sort();
+                dynos.sort((a, b) => {
+                    const apt = this.getProcessType(a);
+                    const bpt = this.getProcessType(b);
+                    if (apt > bpt) {
+                        return 1;
+                    }
+                    if (apt < bpt) {
+                        return -1;
+                    }
+                    return this.getProcessNum(a) - this.getProcessNum(b);
+                });
+                const info = appInfo.find(info => info.id === app.id);
+                let header = info?.name;
+                if (formations.length > 0) {
+                    header += ` (${color.info(formations.join(', '))})`;
+                }
+                hux.styledHeader(header || '');
+                hux.styledObject({
+                    Domains: domains, Dynos: dynos,
+                }, ['Domains', 'Dynos']);
+                ux.stdout();
+            });
+        }
+    }
+    async run() {
+        const { args, flags } = await this.parse(Topology);
+        const spaceName = flags.space || args.space;
+        if (!spaceName) {
+            ux.error(heredoc(`
+        Error: Missing 1 required arg:
+        space
+        See more help with --help
+      `));
+        }
+        const { body: topology } = await this.heroku.get(`/spaces/${spaceName}/topology`);
+        let appInfo = [];
+        if (topology.apps) {
+            appInfo = await Promise.all(topology.apps.map(async (topologyApp) => {
+                const { body: app } = await this.heroku.get(`/apps/${topologyApp.id}`);
+                return app;
+            }));
+        }
+        this.render(topology, appInfo, flags.json);
+    }
+}

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

@@ -0,0 +1,11 @@
+import { Command } from '@heroku-cli/command';
+export default class Transfer extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        space: import("@oclif/core/interfaces").OptionFlag<string, 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/transfer.js

@@ -0,0 +1,33 @@
+import { color } from '@heroku/heroku-cli-util';
+import { Command, flags } from '@heroku-cli/command';
+import { ux } from '@oclif/core';
+import tsheredoc from 'tsheredoc';
+const heredoc = tsheredoc.default;
+export default class Transfer extends Command {
+    static description = 'transfer a space to another team';
+    static examples = [heredoc(`
+    ${color.command('heroku spaces:transfer --space=space-name --team=team-name')}
+    Transferring space-name to team-name... done
+  `)];
+    static flags = {
+        space: flags.string({ char: 's', description: 'name of space', required: true }),
+        team: flags.string({ char: 't', description: 'desired owner of space', required: true }),
+    };
+    static topic = 'spaces';
+    async run() {
+        const { flags } = await this.parse(Transfer);
+        const { space } = flags;
+        const { team } = flags;
+        try {
+            ux.action.start(`Transferring space ${color.space(space)} to team ${color.green(team)}`);
+            await this.heroku.post(`/spaces/${space}/transfer`, { body: { new_owner: team } });
+        }
+        catch (error) {
+            const { body: { message } } = error;
+            ux.error(message);
+        }
+        finally {
+            ux.action.stop();
+        }
+    }
+}

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 args: {
+        source: 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 hiddenAliases: string[];
+    static topic: string;
+    run(): Promise<void>;
+    private isUniqueRule;
+}

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

@@ -0,0 +1,49 @@
+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 Add extends Command {
+    static args = {
+        source: Args.string({ description: 'IP address in CIDR notation', required: true }),
+    };
+    static description = heredoc(`
+  Add one range to the list of trusted IP ranges
+  Uses CIDR notation.`);
+    static examples = [heredoc(`
+    ${color.command('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`)];
+    static flags = {
+        confirm: flags.string({ description: 'set to space name to bypass confirm prompt' }),
+        space: flags.string({ char: 's', description: 'space to add rule to', required: true }),
+    };
+    static hiddenAliases = ['trusted-ips:add'];
+    static topic = 'spaces';
+    async run() {
+        const { args, flags } = await this.parse(Add);
+        const { space } = flags;
+        const url = `/spaces/${space}/inbound-ruleset`;
+        const { body: ruleset } = await this.heroku.get(url);
+        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, { body: ruleset });
+        ux.stdout(`Added ${color.cyan.bold(args.source)} to 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.');
+        }
+    }
+    isUniqueRule(ruleset, source) {
+        return Array.isArray(ruleset.rules) && !ruleset.rules.some(rs => rs.source === source);
+    }
+}

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/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>;
+    private displayRules;
+}

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

@@ -0,0 +1,59 @@
+import { Command, flags } from '@heroku-cli/command';
+import { Args, ux } from '@oclif/core';
+import { hux } from '@heroku/heroku-cli-util';
+import tsheredoc from 'tsheredoc';
+const heredoc = tsheredoc.default;
+export default class Index extends Command {
+    static topic = 'spaces';
+    static hiddenAliases = ['trusted-ips'];
+    static description = heredoc(`
+  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:
+  `);
+    static flags = {
+        space: flags.string({ char: 's', description: 'space to get inbound rules from' }),
+        json: flags.boolean({ description: 'output in json format' }),
+    };
+    static args = {
+        space: Args.string({ hidden: true }),
+    };
+    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`);
+        if (flags.json) {
+            ux.stdout(JSON.stringify(rules, null, 2));
+        }
+        else {
+            this.displayRules(space, rules);
+        }
+    }
+    displayRules(space, ruleset) {
+        if (ruleset.rules.length > 0) {
+            hux.styledHeader('Trusted IP Ranges');
+            for (const rule of ruleset.rules) {
+                ux.stdout(rule.source);
+            }
+        }
+        else {
+            hux.styledHeader(`${space} has no trusted IP ranges. All inbound web requests to dynos are blocked.`);
+        }
+        // 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 (ruleset.applied) { ... } else { ... }
+        if (ruleset.applied === true) {
+            ux.stdout('Trusted IP rules are applied to this space.');
+        }
+        else if (ruleset.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/trusted-ips/remove.d.ts

@@ -0,0 +1,15 @@
+import { Command } from '@heroku-cli/command';
+export default class Remove extends Command {
+    static args: {
+        source: 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 hiddenAliases: string[];
+    static topic: string;
+    run(): Promise<void>;
+}