heroku 9.0.0-alpha.1 → 9.0.0-alpha.3

package/lib/commands/ps/index.js

@@ -0,0 +1,195 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const color_1 = require("@heroku-cli/color");
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const time_1 = require("../../lib/time");
+const tsheredoc_1 = require("tsheredoc");
+function getProcessNumber(s) {
+    return Number.parseInt(s.split('.', 2)[1], 10);
+}
+function uniqueValues(value, index, self) {
+    return self.indexOf(value) === index;
+}
+function byProcessNumber(a, b) {
+    return getProcessNumber(a.name) - getProcessNumber(b.name);
+}
+function byProcessName(a, b) {
+    if (a.name > b.name) {
+        return 1;
+    }
+    if (b.name > a.name) {
+        return -1;
+    }
+    return 0;
+}
+function byProcessTypeAndNumber(a, b) {
+    if (a.type > b.type) {
+        return 1;
+    }
+    if (b.type > a.type) {
+        return -1;
+    }
+    return getProcessNumber(a.name) - getProcessNumber(b.name);
+}
+function truncate(s) {
+    return s.length > 35 ? `${s.slice(0, 34)}…` : s;
+}
+function printExtended(dynos) {
+    const sortedDynos = dynos.sort(byProcessTypeAndNumber);
+    core_1.ux.table(sortedDynos, {
+        ID: { get: (dyno) => dyno.id },
+        Process: { get: (dyno) => dyno.name },
+        State: { get: (dyno) => `${dyno.state} ${(0, time_1.ago)(new Date(dyno.updated_at))}` },
+        Region: { get: (dyno) => dyno.extended ? dyno.extended.region : '' },
+        'Execution Plane': { get: (dyno) => dyno.extended ? dyno.extended.execution_plane : '' },
+        Fleet: { get: (dyno) => dyno.extended ? dyno.extended.fleet : '' },
+        Instance: { get: (dyno) => dyno.extended ? dyno.extended.instance : '' },
+        IP: { get: (dyno) => dyno.extended ? dyno.extended.ip : '' },
+        Port: { get: (dyno) => dyno.extended ? dyno.extended.port.toString() : '' },
+        AZ: { get: (dyno) => dyno.extended ? dyno.extended.az : '' },
+        Release: { get: (dyno) => dyno.release.version },
+        Command: { get: (dyno) => truncate(dyno.command) },
+        Route: { get: (dyno) => dyno.extended ? dyno.extended.route : '' },
+        Size: { get: (dyno) => dyno.size },
+    }, {
+        'no-truncate': true,
+    });
+}
+async function printAccountQuota(heroku, app, account) {
+    if (app.process_tier !== 'free' && app.process_tier !== 'eco') {
+        return;
+    }
+    if (app.owner.id !== account.id) {
+        return;
+    }
+    const { body: quota } = await heroku.request(`/accounts/${account.id}/actions/get-quota`, { headers: { Accept: 'application/vnd.heroku+json; version=3.account-quotas' } }).catch(() => {
+        return { body: null };
+    });
+    if (!quota || (quota.id && quota.id === 'not_found')) {
+        return;
+    }
+    const remaining = (quota.account_quota === 0) ? 0 : quota.account_quota - quota.quota_used;
+    const percentage = (quota.account_quota === 0) ? 0 : Math.floor(remaining / quota.account_quota * 100);
+    const remainingMinutes = remaining / 60;
+    const hours = Math.floor(remainingMinutes / 60);
+    const minutes = Math.floor(remainingMinutes % 60);
+    const appQuota = quota.apps.find(appQuota => {
+        return appQuota.app_uuid === app.id;
+    });
+    const appQuotaUsed = appQuota ? appQuota.quota_used / 60 : 0;
+    const appPercentage = appQuota ? Math.floor(appQuota.quota_used * 100 / quota.account_quota) : 0;
+    const appHours = Math.floor(appQuotaUsed / 60);
+    const appMinutes = Math.floor(appQuotaUsed % 60);
+    if (app.process_tier === 'eco') {
+        core_1.ux.log(`Eco dyno hours quota remaining this month: ${hours}h ${minutes}m (${percentage}%)`);
+        core_1.ux.log(`Eco dyno usage for this app: ${appHours}h ${appMinutes}m (${appPercentage}%)`);
+        core_1.ux.log('For more information on Eco dyno hours, see:');
+        core_1.ux.log('https://devcenter.heroku.com/articles/eco-dyno-hours');
+        core_1.ux.log();
+    }
+    if (app.process_tier === 'free') {
+        core_1.ux.log(`Free dyno hours quota remaining this month: ${hours}h ${minutes}m (${percentage}%)`);
+        core_1.ux.log(`Free dyno usage for this app: ${appHours}h ${appMinutes}m (${appPercentage}%)`);
+        core_1.ux.log('For more information on dyno sleeping and how to upgrade, see:');
+        core_1.ux.log('https://devcenter.heroku.com/articles/dyno-sleeping');
+        core_1.ux.log();
+    }
+}
+function decorateOneOffDyno(dyno) {
+    const since = (0, time_1.ago)(new Date(dyno.updated_at));
+    // eslint-disable-next-line unicorn/explicit-length-check
+    const size = dyno.size || '1X';
+    const state = dyno.state === 'up' ? color_1.default.green(dyno.state) : color_1.default.yellow(dyno.state);
+    return `${dyno.name} (${color_1.default.cyan(size)}): ${state} ${color_1.default.dim(since)}: ${dyno.command}`;
+}
+function decorateCommandDyno(dyno) {
+    const since = (0, time_1.ago)(new Date(dyno.updated_at));
+    const state = dyno.state === 'up' ? color_1.default.green(dyno.state) : color_1.default.yellow(dyno.state);
+    return `${dyno.name}: ${state} ${color_1.default.dim(since)}`;
+}
+function printDynos(dynos) {
+    const oneOffs = dynos.filter(d => d.type === 'run').sort(byProcessNumber);
+    const commands = dynos.filter(d => d.type !== 'run').map(d => d.command).filter(uniqueValues);
+    // Print one-off dynos
+    if (oneOffs.length > 0) {
+        core_1.ux.styledHeader(`${color_1.default.green('run')}: one-off processes (${color_1.default.yellow(oneOffs.length.toString())})`);
+        oneOffs.forEach(dyno => core_1.ux.log(decorateOneOffDyno(dyno)));
+        core_1.ux.log();
+    }
+    // Print dynos grouped by command
+    commands.forEach(function (command) {
+        const commandDynos = dynos.filter(d => d.command === command).sort(byProcessNumber);
+        const type = commandDynos[0].type;
+        // eslint-disable-next-line unicorn/explicit-length-check
+        const size = commandDynos[0].size || '1X';
+        core_1.ux.styledHeader(`${color_1.default.green(type)} (${color_1.default.cyan(size)}): ${command} (${color_1.default.yellow(commandDynos.length.toString())})`);
+        for (const dyno of commandDynos)
+            core_1.ux.log(decorateCommandDyno(dyno));
+        core_1.ux.log();
+    });
+}
+class Index extends command_1.Command {
+    async run() {
+        const _a = await this.parse(Index), { flags } = _a, restParse = tslib_1.__rest(_a, ["flags"]);
+        const { app, json, extended } = flags;
+        const types = restParse.argv;
+        const suffix = extended ? '?extended=true' : ''; // read previous comment, including this on the request doesn't make any difference.
+        const promises = {
+            dynos: this.heroku.request(`/apps/${app}/dynos${suffix}`),
+            appInfo: this.heroku.request(`/apps/${app}`, { headers: { Accept: 'application/vnd.heroku+json; version=3.process-tier' } }),
+            accountInfo: this.heroku.request('/account'),
+        };
+        const [{ body: dynos }, { body: appInfo }, { body: accountInfo }] = await Promise.all([promises.dynos, promises.appInfo, promises.accountInfo]);
+        const shielded = appInfo.space && appInfo.space.shield;
+        if (shielded) {
+            dynos.forEach(d => {
+                d.size = d.size.replace('Private-', 'Shield-');
+            });
+        }
+        let selectedDynos = dynos;
+        if (types.length > 0) {
+            selectedDynos = selectedDynos.filter(dyno => types.find((t) => dyno.type === t));
+            types.forEach(t => {
+                if (!selectedDynos.some(d => d.type === t)) {
+                    throw new Error(`No ${color_1.default.cyan(t)} dynos on ${color_1.default.magenta(app)}`);
+                }
+            });
+        }
+        selectedDynos = selectedDynos.sort(byProcessName);
+        if (json)
+            core_1.ux.styledJSON(selectedDynos);
+        else if (extended)
+            printExtended(selectedDynos);
+        else {
+            await printAccountQuota(this.heroku, appInfo, accountInfo);
+            if (selectedDynos.length === 0)
+                core_1.ux.log(`No dynos on ${color_1.default.magenta(app)}`);
+            else
+                printDynos(selectedDynos);
+        }
+    }
+}
+exports.default = Index;
+Index.topic = 'ps';
+Index.description = 'list dynos for an app';
+Index.strict = false;
+Index.usage = 'ps [TYPE [TYPE ...]]';
+Index.examples = [(0, tsheredoc_1.default) `
+    $ heroku ps
+    === run: one-off dyno
+    run.1: up for 5m: bash
+    === web: bundle exec thin start -p $PORT
+    web.1: created for 30s
+  `, (0, tsheredoc_1.default) `
+    $ heroku ps run # specifying types
+    === run: one-off dyno
+    run.1: up for 5m: bash
+  `];
+Index.flags = {
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+    json: command_1.flags.boolean({ description: 'display as json' }),
+    extended: command_1.flags.boolean({ char: 'x', hidden: true }), // should be removed? Platform API doesn't serialize extended attributes even if the query param `extended=true` is sent.
+};

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

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

package/lib/commands/ps/restart.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@heroku-cli/command");
+const color_1 = require("@heroku-cli/color");
+const core_1 = require("@oclif/core");
+class Restart extends command_1.Command {
+    async run() {
+        const { args, flags } = await this.parse(Restart);
+        const app = flags.app;
+        const dyno = args.dyno;
+        let msg = 'Restarting';
+        if (dyno)
+            msg += ` ${color_1.default.cyan(dyno)}`;
+        msg += (dyno && dyno.includes('.')) ? ' dyno' : ' dynos';
+        msg += ` on ${color_1.default.app(app)}`;
+        core_1.ux.action.start(msg);
+        await this.heroku.delete(dyno ? `/apps/${app}/dynos/${encodeURIComponent(dyno)}` : `/apps/${app}/dynos`);
+        core_1.ux.action.stop();
+    }
+}
+exports.default = Restart;
+Restart.description = 'restart app dynos';
+Restart.topic = 'ps';
+Restart.aliases = ['dyno:restart'];
+Restart.hiddenAliases = ['restart'];
+Restart.examples = [
+    '$ heroku ps:restart web.1',
+    '$ heroku ps:restart web',
+    '$ heroku ps:restart',
+];
+Restart.help = 'if DYNO is not specified, restarts all dynos on app';
+Restart.args = {
+    dyno: core_1.Args.string({ required: false }),
+};
+Restart.flags = {
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+};

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

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

package/lib/commands/ps/scale.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const color_1 = require("@heroku-cli/color");
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const lodash_1 = require("lodash");
+const tsheredoc_1 = require("tsheredoc");
+const emptyFormationErr = (app) => {
+    return new Error(`No process types on ${color_1.default.magenta(app)}.\nUpload a Procfile to add process types.\nhttps://devcenter.heroku.com/articles/procfile`);
+};
+class Scale extends command_1.Command {
+    async run() {
+        const _a = await this.parse(Scale), { flags } = _a, restParse = tslib_1.__rest(_a, ["flags"]);
+        const argv = restParse.argv;
+        const { app } = flags;
+        // will remove this flag once we have
+        // successfully launched larger dyno sizes
+        let isLargerDyno = false;
+        const { body: largerDynoFeatureFlag } = await this.heroku.get('/account/features/frontend-larger-dynos')
+            .catch((error) => {
+            if (error.statusCode === 404) {
+                return { body: { enabled: false } };
+            }
+            throw error;
+        });
+        function parse(args) {
+            return (0, lodash_1.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);
+        // checks for larger dyno sizes
+        // if the feature is not enabled
+        if (!largerDynoFeatureFlag.enabled) {
+            changes.forEach(({ size }) => {
+                const largerDynoNames = /^(?!standard-[12]x$)(performance|private|shield)-(l-ram|xl|2xl)$/i;
+                isLargerDyno = largerDynoNames.test(size);
+                if (isLargerDyno) {
+                    const availableDynoSizes = 'eco, basic, standard-1x, standard-2x, performance-m, performance-l, private-s, private-m, private-l, shield-s, shield-m, shield-l';
+                    core_1.ux.error(`No such size as ${size}. Use ${availableDynoSizes}.`, { exit: 1 });
+                }
+            });
+        }
+        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);
+            }
+            core_1.ux.log(formation.map(d => `${d.type}=${d.quantity}:${d.size}`)
+                .sort()
+                .join(' '));
+        }
+        else {
+            core_1.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_1.default.green(d.type || '')} at ${d.quantity}:${d.size}`);
+            core_1.ux.action.stop(`done, now running ${output.join(', ')}`);
+        }
+    }
+}
+exports.default = Scale;
+Scale.strict = false;
+Scale.description = (0, tsheredoc_1.default) `
+    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.
+  `;
+Scale.examples = [(0, tsheredoc_1.default) `
+    $ 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.
+  `, (0, tsheredoc_1.default) `
+    $ heroku ps:scale --app APP
+    web=3:Standard-2X worker=1:Standard-1X
+  `];
+Scale.aliases = ['dyno:scale'];
+Scale.hiddenAliases = ['scale'];
+Scale.flags = {
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+};

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

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

package/lib/commands/ps/stop.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@heroku-cli/command");
+const color_1 = require("@heroku-cli/color");
+const core_1 = require("@oclif/core");
+class Stop extends command_1.Command {
+    async run() {
+        const { args, flags } = await this.parse(Stop);
+        const app = flags.app;
+        const dyno = args.dyno;
+        const type = dyno.includes('.') ? 'ps' : 'type';
+        core_1.ux.action.start(`Stopping ${color_1.default.cyan(dyno)} ${type === 'ps' ? 'dyno' : 'dynos'} on ${color_1.default.app(app)}`);
+        await this.heroku.post(`/apps/${app}/dynos/${dyno}/actions/stop`);
+        core_1.ux.action.stop();
+    }
+}
+exports.default = Stop;
+Stop.description = 'stop app dyno';
+Stop.topic = 'ps';
+Stop.aliases = ['dyno:stop', 'ps:kill', 'dyno:kill'];
+Stop.hiddenAliases = ['stop', 'kill'];
+Stop.examples = [
+    '$ heroku ps:stop run.1828',
+    '$ heroku ps:stop run',
+];
+Stop.help = 'stop app dyno or dyno type';
+Stop.args = {
+    dyno: core_1.Args.string({ required: true }),
+};
+Stop.flags = {
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+};

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

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

package/lib/commands/ps/type.js

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const color_1 = require("@heroku-cli/color");
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const lodash_1 = require("lodash");
+const tsheredoc_1 = require("tsheredoc");
+const COST_MONTHLY = {
+    Free: 0,
+    Eco: 0,
+    Hobby: 7,
+    Basic: 7,
+    'Standard-1X': 25,
+    'Standard-2X': 50,
+    'Performance-M': 250,
+    Performance: 500,
+    'Performance-L': 500,
+    '1X': 36,
+    '2X': 72,
+    PX: 576,
+    'Performance-L-RAM': 500,
+    'Performance-XL': 750,
+    'Performance-2XL': 1500,
+};
+const calculateHourly = (size) => COST_MONTHLY[size] / 720;
+const emptyFormationErr = (app) => {
+    return 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 = (0, lodash_1.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;
+        }
+        return {
+            // this rule does not realize `size` isn't used on an array
+            /* eslint-disable unicorn/explicit-length-check */
+            type: color_1.default.green(d.type || ''),
+            size: color_1.default.cyan(d.size),
+            qty: color_1.default.yellow(`${d.quantity}`),
+            'cost/hour': calculateHourly(d.size) ?
+                '~$' + (calculateHourly(d.size) * (d.quantity || 1)).toFixed(3)
+                    .toString() :
+                '',
+            'max cost/month': COST_MONTHLY[d.size] ?
+                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                // @ts-ignore
+                '$' + (COST_MONTHLY[d.size] * d.quantity).toString() :
+                '',
+        };
+    }));
+    const dynoTotalsTableData = Object.keys(dynoTotals)
+        .map(k => ({
+        type: color_1.default.green(k), total: color_1.default.yellow((dynoTotals[k]).toString()),
+    }));
+    if (formation.length === 0) {
+        throw emptyFormationErr(app);
+    }
+    core_1.ux.styledHeader('Dyno Types');
+    core_1.ux.table(formationTableData, {
+        type: {},
+        size: {},
+        qty: {},
+        'cost/hour': {},
+        'max cost/month': {},
+    });
+    core_1.ux.styledHeader('Dyno Totals');
+    core_1.ux.table(dynoTotalsTableData, {
+        type: {},
+        total: {},
+    });
+    if (isShowingEcoCostMessage) {
+        core_1.ux.log('\n$5 (flat monthly fee, shared across all Eco dynos)');
+    }
+};
+class Type extends command_1.Command {
+    async run() {
+        const _a = await this.parse(Type), { flags } = _a, restParse = tslib_1.__rest(_a, ["flags"]);
+        const argv = restParse.argv;
+        const { app } = flags;
+        // will remove this flag once we have
+        // successfully launched larger dyno sizes
+        let isLargerDyno = false;
+        const { body: largerDynoFeatureFlag } = await this.heroku.get('/account/features/frontend-larger-dynos')
+            .catch((error) => {
+            if (error.statusCode === 404) {
+                return { body: { enabled: false } };
+            }
+            throw error;
+        });
+        const parse = async () => {
+            if (!argv || argv.length === 0)
+                return [];
+            const { body: formation } = await this.heroku.get(`/apps/${app}/formation`);
+            if (argv.find(a => a.match(/=/))) {
+                return (0, lodash_1.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.find(p => p.type === type)) {
+                        throw new Error(`Type ${color_1.default.red(type || '')} not found in process formation.\nTypes: ${color_1.default.yellow(formation.map(f => f.type)
+                            .join(', '))}`);
+                    }
+                    return { type, size };
+                }));
+            }
+            return formation.map(p => ({ type: p.type, size: argv[0] }));
+        };
+        const changes = await parse();
+        // checks for larger dyno sizes
+        // if the feature is not enabled
+        if (!largerDynoFeatureFlag.enabled) {
+            changes.forEach(({ size }) => {
+                const largerDynoNames = /^(?!standard-[12]x$)(performance|private|shield)-(l-ram|xl|2xl)$/i;
+                isLargerDyno = largerDynoNames.test(size);
+                if (isLargerDyno) {
+                    const availableDynoSizes = 'eco, basic, standard-1x, standard-2x, performance-m, performance-l, private-s, private-m, private-l, shield-s, shield-m, shield-l';
+                    core_1.ux.error(`No such size as ${size}. Use ${availableDynoSizes}.`, { exit: 1 });
+                }
+            });
+        }
+        if (changes.length > 0) {
+            core_1.ux.action.start(`Scaling dynos on ${color_1.default.magenta(app)}`);
+            await this.heroku.patch(`/apps/${app}/formation`, { body: { updates: changes } });
+            core_1.ux.action.stop();
+        }
+        await displayFormation(this.heroku, app);
+    }
+}
+exports.default = Type;
+Type.strict = false;
+Type.description = (0, tsheredoc_1.default) `
+    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.
+  `;
+Type.aliases = ['ps:resize', 'dyno:resize'];
+Type.hiddenAliases = ['resize', 'dyno:type'];
+Type.flags = {
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+};

package/lib/commands/redis/cli.d.ts

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