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

package/lib/commands/ps/scale.js

@@ -0,0 +1,81 @@
+import { color } from '@heroku/heroku-cli-util';
+import { Command, flags } from '@heroku-cli/command';
+import { ux } from '@oclif/core';
+import _ from 'lodash';
+import tsheredoc from 'tsheredoc';
+const heredoc = tsheredoc.default;
+const emptyFormationErr = (app) => (new Error(`No process types on ${color.app(app)}.\nUpload a Procfile to add process types.\nhttps://devcenter.heroku.com/articles/procfile`));
+export default class Scale extends Command {
+    static aliases = ['dyno:scale'];
+    static description = heredoc `
+    scale dyno quantity up or down
+    Appending a size (eg. web=2:Standard-2X) allows simultaneous scaling and resizing.
+
+    Omitting any arguments will display the app's current dyno formation, in a
+    format suitable for passing back into ps:scale.
+  `;
+    static examples = [heredoc `
+    ${color.command('heroku ps:scale web=3:Standard-2X worker+1 --app APP')}
+    Scaling dynos... done, now running web at 3:Standard-2X, worker at 1:Standard-1X.
+  `, heredoc `
+    ${color.command('heroku ps:scale --app APP')}
+    web=3:Standard-2X worker=1:Standard-1X
+  `];
+    static flags = {
+        app: flags.app({ required: true }),
+        remote: flags.remote(),
+    };
+    static hiddenAliases = ['scale'];
+    static strict = false;
+    async run() {
+        const { flags, ...restParse } = await this.parse(Scale);
+        const argv = restParse.argv;
+        const { app } = flags;
+        function parse(args) {
+            return _.compact(args.map(arg => {
+                const change = arg.match(/^([\w-]+)([=+-]\d+)(?::([\w-]+))?$/);
+                if (!change)
+                    return;
+                const quantity = change[2][0] === '=' ? change[2].slice(1) : change[2];
+                if (change[3])
+                    change[3] = change[3].replace('Shield-', 'Private-');
+                return { type: change[1], quantity, size: change[3] };
+            }));
+        }
+        const changes = parse(argv);
+        if (changes.length === 0) {
+            const { body: formation } = await this.heroku.get(`/apps/${app}/formation`);
+            const { body: appProps } = await this.heroku.get(`/apps/${app}`);
+            const shielded = appProps.space && appProps.space.shield;
+            if (shielded) {
+                formation.forEach(d => {
+                    if (d.size !== undefined) {
+                        d.size = d.size.replace('Private-', 'Shield-');
+                    }
+                });
+            }
+            if (formation.length === 0) {
+                throw emptyFormationErr(app);
+            }
+            ux.stdout(formation.map(d => `${d.type}=${d.quantity}:${d.size}`)
+                .sort()
+                .join(' '));
+        }
+        else {
+            ux.action.start('Scaling dynos');
+            const { body: appProps } = await this.heroku.get(`/apps/${app}`);
+            const { body: formation } = await this.heroku.patch(`/apps/${app}/formation`, { body: { updates: changes } });
+            const shielded = appProps.space && appProps.space.shield;
+            if (shielded) {
+                formation.forEach(d => {
+                    if (d.size !== undefined) {
+                        d.size = d.size.replace('Private-', 'Shield-');
+                    }
+                });
+            }
+            const output = formation.filter(f => changes.find(c => c.type === f.type))
+                .map(d => `${color.green(d.type || '')} at ${d.quantity}:${d.size}`);
+            ux.action.stop(`done, now running ${output.join(', ')}`);
+        }
+    }
+}

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

@@ -0,0 +1,18 @@
+import { Command } from '@heroku-cli/command';
+export default class Stop extends Command {
+    static aliases: string[];
+    static args: {
+        dyno: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        app: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        'dyno-name': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'process-type': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        remote: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    static hiddenAliases: string[];
+    static topic: string;
+    run(): Promise<void>;
+}

package/lib/commands/ps/stop.js

@@ -0,0 +1,62 @@
+import { color } from '@heroku/heroku-cli-util';
+import { Command, flags } from '@heroku-cli/command';
+import { ProcessTypeCompletion } from '@heroku-cli/command/lib/completions.js';
+import { Args, ux } from '@oclif/core';
+import tsheredoc from 'tsheredoc';
+const heredoc = tsheredoc.default;
+export default class Stop extends Command {
+    static aliases = ['dyno:stop', 'ps:kill', 'dyno:kill'];
+    static args = {
+        dyno: Args.string({ deprecated: true, description: 'name of the dyno to stop', required: false }),
+    };
+    static description = 'stop an app dyno or process type';
+    static examples = [
+        color.command('heroku ps:stop --app myapp --dyno-name run.1828'),
+        color.command('heroku ps:stop --app myapp --process-type run'),
+    ];
+    static flags = {
+        app: flags.app({ required: true }),
+        'dyno-name': flags.string({
+            char: 'd',
+            description: 'name of the dyno to stop',
+        }),
+        'process-type': flags.string({
+            char: 'p',
+            completion: ProcessTypeCompletion,
+            description: 'name of the process type to stop',
+            exclusive: ['dyno-name'],
+        }),
+        remote: flags.remote(),
+    };
+    static hiddenAliases = ['stop', 'kill'];
+    static topic = 'ps';
+    async run() {
+        const { args, flags } = await this.parse(Stop);
+        const { app } = flags;
+        const dyno = flags['dyno-name'] || args.dyno;
+        const type = flags['process-type'];
+        let msg = 'Stopping';
+        let stopUrl = '';
+        if (type) {
+            msg += ` all ${color.info(type)} dynos`;
+            stopUrl = `/apps/${app}/formations/${encodeURIComponent(type)}/actions/stop`;
+        }
+        else if (dyno) {
+            if (args.dyno) {
+                ux.warn(`DYNO is a deprecated argument. Use ${color.code('--dyno-name')} or ${color.code('--process-type')} instead.`);
+            }
+            msg += ` dyno ${color.name(dyno)}`;
+            stopUrl = `/apps/${app}/dynos/${encodeURIComponent(dyno)}/actions/stop`;
+        }
+        else {
+            ux.error(heredoc(`
+        Please specify a process type or dyno name to stop.
+        See more help with --help
+      `));
+        }
+        msg += ` on ${color.app(app)}`;
+        ux.action.start(msg);
+        await this.heroku.post(stopUrl, { headers: { Accept: 'application/vnd.heroku+json; version=3.sdk' } });
+        ux.action.stop();
+    }
+}

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

@@ -0,0 +1,12 @@
+import { Command } from '@heroku-cli/command';
+export default class Type extends Command {
+    static aliases: string[];
+    static description: string;
+    static flags: {
+        app: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        remote: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    static hiddenAliases: string[];
+    static strict: boolean;
+    run(): Promise<void>;
+}

package/lib/commands/ps/type.js

@@ -0,0 +1,168 @@
+import { color, hux } from '@heroku/heroku-cli-util';
+import { Command, flags } from '@heroku-cli/command';
+import { ux } from '@oclif/core';
+import _ from 'lodash';
+import tsheredoc from 'tsheredoc';
+const heredoc = tsheredoc.default;
+const COST_MONTHLY = {
+    '1X': 36,
+    '2X': 72,
+    Basic: 7,
+    Eco: 0,
+    Free: 0,
+    Hobby: 7,
+    PX: 576,
+    Performance: 500,
+    'Performance-2XL': 1500,
+    'Performance-L': 500,
+    'Performance-L-RAM': 500,
+    'Performance-M': 250,
+    'Performance-XL': 750,
+    'Private-L': 900,
+    'Private-M': 450,
+    'Private-Memory-2XL': 1500,
+    'Private-Memory-L': 500,
+    'Private-Memory-XL': 750,
+    'Private-S': 225,
+    'Shield-L': 1080,
+    'Shield-M': 540,
+    'Shield-Memory-2XL': 1800,
+    'Shield-Memory-L': 600,
+    'Shield-Memory-XL': 900,
+    'Shield-S': 270,
+    'Standard-1X': 25,
+    'Standard-2X': 50,
+    'dyno-1c-0.5gb': 25,
+    'dyno-1c-4gb': 80,
+    'dyno-1c-8gb': 100,
+    'dyno-2c-1gb': 50,
+    'dyno-2c-4gb': 150,
+    'dyno-2c-8gb': 160,
+    'dyno-2c-16gb': 250,
+    'dyno-4c-8gb': 300,
+    'dyno-4c-16gb': 320,
+    'dyno-4c-32gb': 500,
+    'dyno-8c-16gb': 600,
+    'dyno-8c-32gb': 640,
+    'dyno-8c-64gb': 750,
+    'dyno-16c-32gb': 1200,
+    'dyno-16c-64gb': 1000,
+    'dyno-16c-128gb': 1500,
+    'dyno-32c-64gb': 2400,
+};
+const calculateHourly = (size) => COST_MONTHLY[size] / 720;
+const emptyFormationErr = (app) => (new Error(`No process types on ${app}.\nUpload a Procfile to add process types.\nhttps://devcenter.heroku.com/articles/procfile`));
+const displayFormation = async (heroku, app) => {
+    const { body: formation } = await heroku.get(`/apps/${app}/formation`);
+    const { body: appProps } = await heroku.get(`/apps/${app}`);
+    const shielded = appProps.space && appProps.space.shield;
+    const dynoTotals = {};
+    let isShowingEcoCostMessage = false;
+    const formationTableData = _.sortBy(formation, 'type')
+        // this filter shouldn't be necessary, but it makes TS happy
+        .filter((f) => typeof f.size === 'string' && typeof f.quantity === 'number')
+        .map((d => {
+        if (d.size === 'Eco') {
+            isShowingEcoCostMessage = true;
+        }
+        if (shielded) {
+            d.size = d.size.replace('Private-', 'Shield-');
+        }
+        if (d.size in dynoTotals) {
+            dynoTotals[d.size] += d.quantity;
+        }
+        else {
+            dynoTotals[d.size] = d.quantity;
+        }
+        /* eslint-disable perfectionist/sort-objects */
+        return {
+            // this rule does not realize `size` isn't used on an array
+            type: color.name(d.type || ''),
+            size: color.info(d.size),
+            qty: color.info(`${d.quantity}`),
+            'cost/hour': calculateHourly(d.size)
+                ? '~$' + (calculateHourly(d.size) * (d.quantity || 1)).toFixed(3).toString()
+                : '',
+            'max cost/month': COST_MONTHLY[d.size]
+                ? '$' + (COST_MONTHLY[d.size] * d.quantity).toString()
+                : '',
+        };
+        /* eslint-enable perfectionist/sort-objects */
+    }));
+    const dynoTotalsTableData = Object.keys(dynoTotals)
+        .map(k => ({
+        // eslint-disable-next-line perfectionist/sort-objects
+        type: color.name(k), total: color.info((dynoTotals[k]).toString()),
+    }));
+    if (formation.length === 0) {
+        throw emptyFormationErr(app);
+    }
+    hux.styledHeader('Process Types');
+    /* eslint-disable perfectionist/sort-objects */
+    hux.table(formationTableData, {
+        type: {},
+        size: {},
+        qty: {},
+        'cost/hour': {},
+        'max cost/month': {},
+    });
+    /* eslint-enable perfectionist/sort-objects */
+    ux.stdout();
+    hux.styledHeader('Dyno Totals');
+    hux.table(dynoTotalsTableData, {
+        type: {},
+        // eslint-disable-next-line perfectionist/sort-objects
+        total: {},
+    });
+    if (isShowingEcoCostMessage) {
+        ux.stdout('\n$5 (flat monthly fee, shared across all Eco dynos)');
+    }
+};
+export default class Type extends Command {
+    static aliases = ['ps:resize', 'dyno:resize'];
+    static description = heredoc `
+    manage dyno sizes
+    Called with no arguments shows the current dyno size.
+
+    Called with one argument sets the size.
+    Where SIZE is one of eco|basic|standard-1x|standard-2x|performance
+
+    Called with 1..n TYPE=SIZE arguments sets the quantity per type.
+  `;
+    static flags = {
+        app: flags.app({ required: true }),
+        remote: flags.remote(),
+    };
+    static hiddenAliases = ['resize', 'dyno:type'];
+    static strict = false;
+    async run() {
+        const { flags, ...restParse } = await this.parse(Type);
+        const argv = restParse.argv;
+        const { app } = flags;
+        const parse = async () => {
+            if (!argv || argv.length === 0)
+                return [];
+            const { body: formation } = await this.heroku.get(`/apps/${app}/formation`);
+            if (argv.some(a => a.match(/=/))) {
+                return _.compact(argv.map(arg => {
+                    const match = arg.match(/^([a-zA-Z0-9_]+)=([\w-]+)$/);
+                    const type = match && match[1];
+                    const size = match && match[2];
+                    if (!type || !size || !formation.some(p => p.type === type)) {
+                        throw new Error(`Type ${color.failure(type || '')} not found in process formation.\nTypes: ${color.info(formation.map(f => f.type)
+                            .join(', '))}`);
+                    }
+                    return { type, size };
+                }));
+            }
+            return formation.map(p => ({ type: p.type, size: argv[0] }));
+        };
+        const changes = await parse();
+        if (changes.length > 0) {
+            ux.action.start(`Scaling dynos on ${color.app(app)}`);
+            await this.heroku.patch(`/apps/${app}/formation`, { body: { updates: changes } });
+            ux.action.stop();
+        }
+        await displayFormation(this.heroku, app);
+    }
+}

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

@@ -0,0 +1,13 @@
+import { Command } from '@heroku-cli/command';
+export default class Wait extends Command {
+    static description: string;
+    static flags: {
+        app: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        remote: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        type: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'wait-interval': import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+        'with-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    static topic: string;
+    run(): Promise<void>;
+}

package/lib/commands/ps/wait.js

@@ -0,0 +1,73 @@
+import { color, hux } from '@heroku/heroku-cli-util';
+import { Command, flags } from '@heroku-cli/command';
+import { ux } from '@oclif/core';
+export default class Wait extends Command {
+    static description = 'wait for all dynos to be running latest version after a release';
+    static flags = {
+        app: flags.app({ required: true }),
+        remote: flags.remote(),
+        type: flags.string({
+            char: 't',
+            description: 'wait for one specific dyno type',
+        }),
+        'wait-interval': flags.integer({
+            char: 'w',
+            default: 10,
+            description: 'how frequently to poll in seconds (to avoid hitting Heroku API rate limits)',
+            async parse(input) {
+                const w = Number.parseInt(input, 10);
+                if (w < 10) {
+                    ux.error('wait-interval must be at least 10', { exit: 1 });
+                }
+                return w;
+            },
+        }),
+        'with-run': flags.boolean({
+            char: 'R',
+            description: 'whether to wait for one-off run dynos',
+            exclusive: ['type'],
+        }),
+    };
+    static topic = 'ps';
+    async run() {
+        const { flags } = await this.parse(Wait);
+        const { body: releases } = await this.heroku.request(`/apps/${flags.app}/releases`, {
+            headers: {
+                Range: 'version ..; max=1, order=desc',
+            },
+            partial: true,
+        });
+        if (releases.length === 0) {
+            this.warn(`App ${color.app(flags.app)} has no releases`);
+            return;
+        }
+        const latestRelease = releases[0];
+        let released = true;
+        const interval = flags['wait-interval'];
+        while (1) {
+            const { body: dynos } = await this.heroku.get(`/apps/${flags.app}/dynos`);
+            const relevantDynos = dynos
+                .filter(dyno => dyno.type !== 'release')
+                .filter(dyno => flags['with-run'] || dyno.type !== 'run')
+                .filter(dyno => !flags.type || dyno.type === flags.type);
+            const onLatest = relevantDynos.filter((dyno) => (dyno.state === 'up'
+                && latestRelease.version !== undefined
+                && dyno.release !== undefined
+                && dyno.release.version !== undefined
+                && dyno.release.version >= latestRelease.version));
+            const releasedFraction = `${onLatest.length} / ${relevantDynos.length}`;
+            if (onLatest.length === relevantDynos.length) {
+                if (!released) {
+                    ux.action.stop(`${releasedFraction}, done`);
+                }
+                break;
+            }
+            if (released) {
+                released = false;
+                ux.action.start(`Waiting for every dyno to be running v${latestRelease.version}`);
+            }
+            ux.action.status = releasedFraction;
+            await hux.wait(interval * 1000);
+        }
+    }
+}

package/lib/commands/regions.d.ts

@@ -1,11 +1,11 @@
 import { Command } from '@heroku-cli/command';
 export default class Regions extends Command {
-    static topic: string;
     static description: string;
     static flags: {
+        common: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         private: import("@oclif/core/interfaces").BooleanFlag<boolean>;
-        common: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
+    static topic: string;
     run(): Promise<void>;
 }

package/lib/commands/regions.js

@@ -1,14 +1,13 @@
-import { color } from '@heroku-cli/color';
+import { color, hux } from '@heroku/heroku-cli-util';
 import { Command, flags } from '@heroku-cli/command';
-import { hux } from '@heroku/heroku-cli-util';
 export default class Regions extends Command {
-    static topic = 'regions';
     static description = 'list available regions for deployment';
     static flags = {
+        common: flags.boolean({ description: 'show regions for common runtime' }),
         json: flags.boolean({ description: 'output in json format' }),
         private: flags.boolean({ description: 'show regions for private spaces' }),
-        common: flags.boolean({ description: 'show regions for common runtime' }),
     };
+    static topic = 'regions';
     async run() {
         const { flags } = await this.parse(Regions);
         let { body: regions } = await this.heroku.get('/regions');
@@ -28,10 +27,11 @@ export default class Regions extends Command {
             hux.styledJSON(regions);
         }
         else {
+            /* eslint-disable perfectionist/sort-objects */
             hux.table(regions, {
                 name: {
                     header: 'ID',
-                    get: ({ name }) => color.green(name),
+                    get: ({ name }) => color.name(name),
                 },
                 description: {
                     header: 'Location',
@@ -41,6 +41,7 @@ export default class Regions extends Command {
                     get: ({ private_capable }) => private_capable ? 'Private Spaces' : 'Common Runtime',
                 },
             });
+            /* eslint-enable perfectionist/sort-objects */
         }
     }
 }

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

@@ -0,0 +1,14 @@
+import { Command } from '@heroku-cli/command';
+export default class Index extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        app: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        extended: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        num: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        remote: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    static topic: string;
+    run(): Promise<void>;
+}

package/lib/commands/releases/index.js

@@ -0,0 +1,155 @@
+import ansis from 'ansis';
+import { color, hux } from '@heroku/heroku-cli-util';
+import { Command, flags } from '@heroku-cli/command';
+import { ux } from '@oclif/core';
+import _ from 'lodash';
+import * as statusHelper from '../../lib/releases/status_helper.js';
+import * as time from '../../lib/time.js';
+const getDescriptionTruncation = function (releases, columns, optimizeKey) {
+    // width management here is quite opaque.
+    // This entire function is to determine how much of Formation.description should be truncated to accommodate for Formation.status. They both go in the same column.
+    // Nothing else is truncated and the table is passed `'no-truncate': true` in options.
+    let optimizationWidth = 0;
+    const optimizationWidthMap = {};
+    for (const key of Object.keys(columns)) {
+        optimizationWidthMap[key] = 0;
+    }
+    for (const row of releases) {
+        for (const colKey in row) {
+            if (colKey === optimizeKey) {
+                continue;
+            }
+            for (const [key, col] of Object.entries(columns)) {
+                const parts = key.split('.');
+                const matchKey = parts[0];
+                if (matchKey !== colKey) {
+                    continue;
+                }
+                let colValue = row;
+                for (const part of parts) {
+                    colValue = colValue[part];
+                }
+                let formattedValue;
+                if (col.get) {
+                    formattedValue = col.get(row);
+                }
+                else {
+                    formattedValue = colValue.toString();
+                }
+                if (key !== optimizeKey) {
+                    optimizationWidthMap[key] = Math.max(optimizationWidthMap[key], ansis.strip(String(formattedValue)).length);
+                }
+            }
+        }
+    }
+    for (const key of Object.keys(columns)) {
+        if (key !== optimizeKey) {
+            optimizationWidth += optimizationWidthMap[key] + 2;
+        }
+    }
+    return optimizationWidth;
+};
+export default class Index extends Command {
+    static description = 'display the releases for an app';
+    static examples = [
+        `${color.command('v1 Config add FOO_BAR email@example.com 2015/11/17 17:37:41 (~ 1h ago)')}`,
+        `${color.command('v2 Config add BAR_BAZ email@example.com 2015/11/17 17:37:41 (~ 1h ago)')}`,
+        `${color.command('v3 Config add BAZ_QUX email@example.com 2015/11/17 17:37:41 (~ 1h ago)')}`,
+    ];
+    static flags = {
+        app: flags.app({ required: true }),
+        extended: flags.boolean({ char: 'x', hidden: true }),
+        json: flags.boolean({ description: 'output releases in json format' }),
+        num: flags.string({ char: 'n', description: 'number of releases to show' }),
+        remote: flags.remote(),
+    };
+    static topic = 'releases';
+    async run() {
+        const { flags } = await this.parse(Index);
+        const { app, extended, json, num } = flags;
+        const url = `/apps/${app}/releases${extended ? '?extended=true' : ''}`;
+        const { body: releases } = await this.heroku.request(url, {
+            headers: {
+                Accept: 'application/vnd.heroku+json; version=3.sdk',
+                Range: `version ..; max=${num || 15}, order=desc`,
+            },
+            partial: true,
+        });
+        let optimizationWidth = 0;
+        const descriptionWithStatus = function (release) {
+            const { description } = release;
+            const width = () => process.stdout?.columns && process.stdout.columns > 80 ? process.stdout.columns : 80;
+            const trunc = (l, s) => {
+                if (process.stdout.isTTY) {
+                    return _.truncate(s, { length: width() - (optimizationWidth + l), omission: '…' });
+                }
+                return s;
+            };
+            const status = statusHelper.description(release);
+            if (status) {
+                const statusColor = statusHelper.color(release.status);
+                let colorFn;
+                switch (statusColor) {
+                    case 'red': {
+                        colorFn = color.failure;
+                        break;
+                    }
+                    case 'yellow': {
+                        colorFn = color.warning;
+                        break;
+                    }
+                    case 'gray': {
+                        colorFn = color.inactive;
+                        break;
+                    }
+                    default: {
+                        colorFn = color.info;
+                    }
+                }
+                const sc = colorFn(status);
+                return trunc(status.length + 1, description) + ' ' + sc;
+            }
+            return trunc(0, description);
+        };
+        const getVersionColor = (release) => {
+            const statusColor = statusHelper.color(release.status);
+            if (statusColor === 'red')
+                return color.failure('v' + release.version);
+            if (statusColor === 'yellow')
+                return color.warning('v' + release.version);
+            if (statusColor === 'gray')
+                return color.inactive('v' + release.version);
+            return color.name('v' + release.version);
+        };
+        /* eslint-disable perfectionist/sort-objects */
+        const columns = {
+            // column name "v" as ux.table will make it's width at least "version" even though 'no-header': true
+            v: { get: getVersionColor },
+            description: { get: descriptionWithStatus },
+            user: { get: ({ user }) => color.user(user?.email || '') },
+            created_at: { get: ({ created_at }) => time.ago(new Date(created_at || '')) },
+            slug_id: { extended: true, get: ({ extended }) => extended?.slug_id },
+            slug_uuid: { extended: true, get: ({ extended }) => extended?.slug_uuid },
+        };
+        /* eslint-enable perfectionist/sort-objects */
+        // `getDescriptionTruncation` is dependent on `columns` being defined and thus `descriptionWithStatus`.
+        // `descriptionWithStatus` requires `optimizationWidth` to be defined. Redefine here before `descriptionWithStatus` is actually called.
+        optimizationWidth = getDescriptionTruncation(releases, columns, 'description');
+        if (json) {
+            hux.styledJSON(releases);
+        }
+        else if (releases.length === 0) {
+            ux.stdout(`${color.app(app)} has no releases.`);
+        }
+        else {
+            let header = `${color.app(app)} Releases`;
+            const currentRelease = releases.find(r => r.current === true);
+            if (currentRelease) {
+                header += ' - ' + color.name(`Current: v${currentRelease.version}`);
+            }
+            hux.styledHeader(header);
+            const sortedReleases = releases.sort((a, b) => (b.version ?? 0) - (a.version ?? 0));
+            hux.table(sortedReleases, columns);
+        }
+    }
+}

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

@@ -0,0 +1,15 @@
+import { Command } from '@heroku-cli/command';
+export default class Info extends Command {
+    static args: {
+        release: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static flags: {
+        app: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        remote: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        shell: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    static topic: string;
+    run(): Promise<void>;
+}