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

package/lib/commands/pipelines/transfer.js

@@ -0,0 +1,60 @@
+import { color, hux } from '@heroku/heroku-cli-util';
+import { Command, flags } from '@heroku-cli/command';
+import { Args, ux } from '@oclif/core';
+import { createPipelineTransfer, getAccountInfo, getTeam, listPipelineApps, } from '../../lib/api.js';
+import disambiguate from '../../lib/pipelines/disambiguate.js';
+import renderPipeline from '../../lib/pipelines/render-pipeline.js';
+async function getTeamOwner(heroku, name) {
+    const { body: team } = await getTeam(heroku, name);
+    return { id: team.id, type: 'team' };
+}
+async function getAccountOwner(heroku, name) {
+    const { body: account } = await getAccountInfo(heroku, name);
+    return { id: account.id, type: 'user' };
+}
+function getOwner(heroku, name) {
+    return getTeamOwner(heroku, name)
+        .catch(() => getAccountOwner(heroku, name))
+        .catch(() => {
+        throw new Error(`Cannot find a team or account for "${name}"`);
+    });
+}
+export default class PipelinesTransfer extends Command {
+    static args = {
+        owner: Args.string({
+            description: 'the owner to transfer the pipeline to',
+            required: true,
+        }),
+    };
+    static description = 'transfer ownership of a pipeline';
+    static examples = [
+        color.command('heroku pipelines:transfer admin@example.com -p my-pipeline'),
+        color.command('heroku pipelines:transfer admin-team -p my-pipeline'),
+    ];
+    static flags = {
+        confirm: flags.string({ char: 'c' }),
+        pipeline: flags.pipeline({ required: true }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(PipelinesTransfer);
+        const pipeline = await disambiguate(this.heroku, flags.pipeline);
+        const newOwner = await getOwner(this.heroku, args.owner);
+        const apps = await listPipelineApps(this.heroku, pipeline.id);
+        const displayType = newOwner.type === 'user' ? 'account' : newOwner.type;
+        let confirmName = flags.confirm;
+        if (!confirmName) {
+            await renderPipeline(this.heroku, pipeline, apps);
+            ux.stdout('');
+            ux.warn(`This will transfer ${color.pipeline(pipeline.name)} and all of the listed apps to the ${args.owner} ${displayType}`);
+            ux.warn(`to proceed, type ${color.pipeline(pipeline.name)} or re-run this command with ${color.info('--confirm')} ${pipeline.name}`);
+            confirmName = await hux.prompt('', {});
+        }
+        if (confirmName !== pipeline.name) {
+            ux.warn(`Confirmation did not match ${color.pipeline(pipeline.name)}. Aborted.`);
+            return;
+        }
+        ux.action.start(`Transferring ${color.pipeline(pipeline.name)} pipeline to the ${args.owner} ${displayType}`);
+        await createPipelineTransfer(this.heroku, { new_owner: newOwner, pipeline: { id: pipeline.id } });
+        ux.action.stop();
+    }
+}

package/lib/commands/pipelines/update.d.ts

@@ -0,0 +1,11 @@
+import { Command } from '@heroku-cli/command';
+export default class PipelinesUpdate extends Command {
+    static description: string;
+    static examples: 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>;
+        stage: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/pipelines/update.js

@@ -0,0 +1,29 @@
+import { color } from '@heroku/heroku-cli-util';
+import { Command, flags } from '@heroku-cli/command';
+import { StageCompletion } from '@heroku-cli/command/lib/completions.js';
+import { ux } from '@oclif/core';
+import { updateCoupling } from '../../lib/api.js';
+export default class PipelinesUpdate extends Command {
+    static description = 'update the app\'s stage in a pipeline';
+    static examples = [
+        color.command('heroku pipelines:update -s staging -a my-app'),
+    ];
+    static flags = {
+        app: flags.app({ required: true }),
+        remote: flags.remote(),
+        stage: flags.string({
+            char: 's',
+            completion: StageCompletion,
+            description: 'new stage of app',
+            required: true,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(PipelinesUpdate);
+        const { app } = flags;
+        const { stage } = flags;
+        ux.action.start(`Changing ${color.app(app)} to ${stage}`);
+        await updateCoupling(this.heroku, app, stage);
+        ux.action.stop();
+    }
+}

package/lib/commands/prompt.d.ts

@@ -1,8 +1,8 @@
 import { Command } from '@oclif/core';
 export default class Prompt extends Command {
     static description: string;
-    static hidden: boolean;
     static examples: string[];
+    static hidden: boolean;
     static strict: boolean;
     run(): Promise<void>;
 }

package/lib/commands/prompt.js

@@ -1,11 +1,12 @@
+import { color } from '@heroku/heroku-cli-util';
 import { Command, ux } from '@oclif/core';
 export default class Prompt extends Command {
     static description = 'interactively prompt for command arguments and flags';
-    static hidden = true;
     static examples = [
-        '$ heroku apps:info --prompt',
-        '$ heroku config:set --prompt',
+        color.command('heroku apps:info --prompt'),
+        color.command('heroku config:set --prompt'),
     ];
+    static hidden = true;
     static strict = false;
     async run() {
         ux.warn('use `heroku <COMMAND> --prompt` to interactively prompt for command arguments and flags');

package/lib/commands/ps/autoscale/disable.d.ts

@@ -0,0 +1,10 @@
+import { Command } from '@heroku-cli/command';
+export default class Disable extends Command {
+    static description: string;
+    static topic: 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>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/ps/autoscale/disable.js

@@ -0,0 +1,33 @@
+import { Command, flags } from '@heroku-cli/command';
+import { ux } from '@oclif/core';
+const METRICS_HOST = 'api.metrics.heroku.com';
+export default class Disable extends Command {
+    static description = 'disable web dyno autoscaling';
+    static topic = 'ps:autoscale';
+    static flags = {
+        app: flags.app({ required: true }),
+        remote: flags.remote(),
+    };
+    async run() {
+        const { flags } = await this.parse(Disable);
+        ux.action.start('Disabling dyno autoscaling');
+        const appResponse = await this.heroku.get(`/apps/${flags.app}`);
+        const app = appResponse.body;
+        const monitorsResponse = await this.heroku.get(`/apps/${app.id}/formation/web/monitors`, {
+            hostname: METRICS_HOST,
+        });
+        const monitors = monitorsResponse.body;
+        const scaleMonitor = monitors.find((m) => m.action_type === 'scale');
+        if (!scaleMonitor)
+            throw new Error(`${flags.app} does not have autoscale enabled`);
+        await this.heroku.patch(`/apps/${app.id}/formation/web/monitors/${scaleMonitor.id}`, {
+            hostname: METRICS_HOST,
+            body: {
+                is_active: false,
+                period: 1,
+                op: 'GREATER_OR_EQUAL',
+            },
+        });
+        ux.action.stop();
+    }
+}

package/lib/commands/ps/autoscale/enable.d.ts

@@ -0,0 +1,14 @@
+import { Command } from '@heroku-cli/command';
+export default class Enable extends Command {
+    static description: string;
+    static topic: 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>;
+        min: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+        max: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+        p95: import("@oclif/core/interfaces").OptionFlag<number | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        notifications: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/ps/autoscale/enable.js

@@ -0,0 +1,84 @@
+import { Command, flags } from '@heroku-cli/command';
+import { ux } from '@oclif/core';
+import { getGeneration } from '../../../lib/apps/generation.js';
+const METRICS_HOST = 'api.metrics.heroku.com';
+const isPerfOrPrivateTier = (size) => {
+    const applicableTiers = ['performance', 'private', 'shield'];
+    return applicableTiers.some(tier => size.toLowerCase().includes(tier));
+};
+export default class Enable extends Command {
+    static description = 'enable web dyno autoscaling';
+    static topic = 'ps:autoscale';
+    static flags = {
+        app: flags.app({ required: true }),
+        remote: flags.remote(),
+        min: flags.integer({ required: true, description: 'minimum number of dynos' }),
+        max: flags.integer({ required: true, description: 'maximum number of dynos' }),
+        p95: flags.integer({ description: 'desired p95 response time' }),
+        notifications: flags.boolean({ description: 'receive email notifications when the max dyno limit is reached' }),
+    };
+    async run() {
+        const { flags } = await this.parse(Enable);
+        ux.action.start('Enabling dyno autoscaling');
+        const [appResponse, formationResponse] = await Promise.all([
+            this.heroku.get(`/apps/${flags.app}`, {
+                headers: {
+                    Accept: 'application/vnd.heroku+json; version=3.sdk',
+                },
+            }),
+            this.heroku.get(`/apps/${flags.app}/formation`, {
+                headers: {
+                    Accept: 'application/vnd.heroku+json; version=3.sdk',
+                },
+            }),
+        ]);
+        const app = appResponse.body;
+        const formations = formationResponse.body;
+        const webFormation = formations.find((f) => f.type === 'web');
+        if (getGeneration(app) === 'fir') {
+            throw new Error('Autoscaling is unavailable for apps in this space. See https://devcenter.heroku.com/articles/generations.');
+        }
+        if (!webFormation)
+            throw new Error(`${flags.app} does not have any web dynos to scale`);
+        const { size } = webFormation;
+        if (!isPerfOrPrivateTier(size || '')) {
+            throw new Error('Autoscaling is only available with Performance or Private dynos');
+        }
+        const { body } = await this.heroku.get(`/apps/${app.id}/formation/web/monitors`, {
+            hostname: METRICS_HOST,
+        });
+        const scaleMonitor = (body || []).find((m) => m.action_type === 'scale');
+        let updatedValues = {
+            is_active: true,
+            action_type: 'scale',
+            notification_period: 1440,
+            op: 'GREATER_OR_EQUAL',
+            period: 1,
+            notification_channels: flags.notifications ? ['app'] : [],
+        };
+        if (scaleMonitor) {
+            updatedValues = { ...updatedValues,
+                min_quantity: flags.min || scaleMonitor.min_quantity,
+                max_quantity: flags.max || scaleMonitor.max_quantity,
+                value: flags.p95 || scaleMonitor.value,
+            };
+            await this.heroku.patch(`/apps/${app.id}/formation/web/monitors/${scaleMonitor.id}`, {
+                body: updatedValues,
+                hostname: METRICS_HOST,
+            });
+        }
+        else {
+            updatedValues = { ...updatedValues,
+                name: 'LATENCY_SCALE',
+                min_quantity: flags.min,
+                max_quantity: flags.max,
+                value: flags.p95 || 1000,
+            };
+            await this.heroku.post(`/apps/${app.id}/formation/web/monitors`, {
+                hostname: METRICS_HOST,
+                body: updatedValues,
+            });
+        }
+        ux.action.stop();
+    }
+}

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

@@ -0,0 +1,15 @@
+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>;
+        remote: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    static strict: boolean;
+    static topic: string;
+    static usage: string;
+    run(): Promise<void>;
+}

package/lib/commands/ps/index.js

@@ -0,0 +1,199 @@
+import { color, hux } from '@heroku/heroku-cli-util';
+import { Command, flags } from '@heroku-cli/command';
+import { ux } from '@oclif/core';
+import tsheredoc from 'tsheredoc';
+import { ago } from '../../lib/time.js';
+const heredoc = tsheredoc.default;
+function getProcessNumber(s) {
+    const [processType, dynoNumber] = (s.match(/^([^.]+)\.(.*)$/) || []).slice(1, 3);
+    if (!processType || !dynoNumber?.match(/^\d+$/))
+        return 0;
+    return Number.parseInt(dynoNumber, 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);
+    /* eslint-disable perfectionist/sort-objects */
+    hux.table(sortedDynos, {
+        ID: { get: (dyno) => dyno.id },
+        Process: { get: (dyno) => dyno.name },
+        State: { get: (dyno) => `${dyno.state} ${ago(new Date(dyno.updated_at))}` },
+        Region: { get: (dyno) => dyno.extended?.region ?? '' },
+        'Execution Plane': { get: (dyno) => dyno.extended?.execution_plane ?? '' },
+        Fleet: { get: (dyno) => dyno.extended?.fleet ?? '' },
+        Instance: { get: (dyno) => dyno.extended?.instance ?? '' },
+        IP: { get: (dyno) => dyno.extended?.ip ?? '' },
+        Port: { get: (dyno) => dyno.extended?.port?.toString() ?? '' },
+        AZ: { get: (dyno) => dyno.extended?.az ?? '' },
+        Release: { get: (dyno) => dyno.release.version },
+        Command: { get: (dyno) => truncate(dyno.command) },
+        Route: { get: (dyno) => dyno.extended?.route ?? '' },
+        Size: { get: (dyno) => dyno.size },
+    }, {
+        overflow: 'wrap',
+    });
+    /* eslint-enable perfectionist/sort-objects */
+}
+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(() => ({ 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 => 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') {
+        ux.stdout(`Eco dyno hours quota remaining this month: ${hours}h ${minutes}m (${percentage}%)`);
+        ux.stdout(`Eco dyno usage for this app: ${appHours}h ${appMinutes}m (${appPercentage}%)`);
+        ux.stdout('For more information on Eco dyno hours, see:');
+        ux.stdout(color.info('https://devcenter.heroku.com/articles/eco-dyno-hours'));
+        ux.stdout();
+    }
+    if (app.process_tier === 'free') {
+        ux.stdout(`Free dyno hours quota remaining this month: ${hours}h ${minutes}m (${percentage}%)`);
+        ux.stdout(`Free dyno usage for this app: ${appHours}h ${appMinutes}m (${appPercentage}%)`);
+        ux.stdout('For more information on dyno sleeping and how to upgrade, see:');
+        ux.stdout(color.info('https://devcenter.heroku.com/articles/dyno-sleeping'));
+        ux.stdout();
+    }
+}
+function decorateOneOffDyno(dyno) {
+    const since = 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.success(dyno.state) : color.warning(dyno.state);
+    return `${dyno.name} (${color.info(size)}): ${state} ${color.dim(since)}: ${dyno.command}`;
+}
+function decorateCommandDyno(dyno) {
+    const since = ago(new Date(dyno.updated_at));
+    const state = dyno.state === 'up' ? color.success(dyno.state) : color.warning(dyno.state);
+    return `${dyno.name}: ${state} ${color.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) {
+        hux.styledHeader(`${color.label('run')}: one-off processes (${oneOffs.length})`);
+        oneOffs.forEach(dyno => ux.stdout(decorateOneOffDyno(dyno)));
+        ux.stdout();
+    }
+    // Print dynos grouped by command
+    commands.forEach(command => {
+        const commandDynos = dynos.filter(d => d.command === command).sort(byProcessNumber);
+        const { size = '1X', type } = commandDynos[0];
+        hux.styledHeader(`${color.label(type)} (${color.info(size)}): ${command} (${commandDynos.length})`);
+        for (const dyno of commandDynos)
+            ux.stdout(decorateCommandDyno(dyno));
+        ux.stdout();
+    });
+}
+export default class Index extends Command {
+    static description = 'list dynos for an app';
+    static examples = [heredoc `
+    ${color.command('heroku ps')}
+    === run: one-off dyno
+    run.1: up for 5m: bash
+    === web: bundle exec thin start -p $PORT
+    web.1: created for 30s
+  `, heredoc `
+    ${color.command('heroku ps run')} # specifying types
+    === run: one-off dyno
+    run.1: up for 5m: bash
+  `];
+    static flags = {
+        app: flags.app({ required: true }),
+        extended: flags.boolean({ char: 'x', hidden: true }),
+        json: flags.boolean({ description: 'display as json' }),
+        remote: flags.remote(),
+    };
+    static strict = false;
+    static topic = 'ps';
+    static usage = 'ps [TYPE [TYPE ...]]';
+    async run() {
+        const { flags, ...restParse } = await this.parse(Index);
+        const { app, extended, json } = flags;
+        const types = restParse.argv;
+        const suffix = extended ? '?extended=true' : '';
+        const promises = {
+            accountInfo: this.heroku.request('/account', {
+                headers: { Accept: 'application/vnd.heroku+json; version=3.sdk' },
+            }),
+            appInfo: this.heroku.request(`/apps/${app}`, {
+                headers: { Accept: 'application/vnd.heroku+json; version=3.sdk' },
+            }),
+            dynos: this.heroku.request(`/apps/${app}/dynos${suffix}`, {
+                headers: { Accept: 'application/vnd.heroku+json; version=3.sdk' },
+            }),
+        };
+        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.info(t)} dynos on ${color.app(app)}`);
+                }
+            });
+        }
+        selectedDynos = selectedDynos.sort(byProcessName);
+        if (json)
+            hux.styledJSON(selectedDynos);
+        else if (extended)
+            printExtended(selectedDynos);
+        else {
+            await printAccountQuota(this.heroku, appInfo, accountInfo);
+            if (selectedDynos.length === 0)
+                ux.stdout(`No dynos on ${color.app(app)}`);
+            else
+                printDynos(selectedDynos);
+        }
+    }
+}

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

@@ -0,0 +1,18 @@
+import { Command } from '@heroku-cli/command';
+export default class Restart 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/restart.js

@@ -0,0 +1,68 @@
+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 Restart extends Command {
+    static aliases = ['dyno:restart'];
+    static args = {
+        dyno: Args.string({ deprecated: true, description: 'name of the dyno to restart', required: false }),
+    };
+    static description = heredoc(`
+    restart an app dyno or process type
+    if neither --dyno nor --type are specified, restarts all dynos on app
+  `);
+    static examples = [
+        `${color.command('heroku ps:restart --app myapp --dyno-name web.1')}`,
+        `${color.command('heroku ps:restart --app myapp --process-type web')}`,
+        `${color.command('heroku ps:restart --app myapp')}`,
+    ];
+    static flags = {
+        app: flags.app({ required: true }),
+        'dyno-name': flags.string({
+            char: 'd',
+            description: 'name of the dyno to restart',
+        }),
+        'process-type': flags.string({
+            char: 'p',
+            completion: ProcessTypeCompletion,
+            description: 'name of the process type to restart',
+            exclusive: ['dyno-name'],
+        }),
+        remote: flags.remote(),
+    };
+    static hiddenAliases = ['restart'];
+    static topic = 'ps';
+    async run() {
+        const { args, flags } = await this.parse(Restart);
+        const { app } = flags;
+        const dyno = flags['dyno-name'] || args.dyno;
+        const type = flags['process-type'];
+        let msg = 'Restarting';
+        let restartUrl;
+        if (type) {
+            msg += ` all ${color.info(type)} dynos`;
+            restartUrl = `/apps/${app}/formations/${encodeURIComponent(type)}`;
+        }
+        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)}`;
+            restartUrl = `/apps/${app}/dynos/${encodeURIComponent(dyno)}`;
+        }
+        else {
+            msg += ' all dynos';
+            restartUrl = `/apps/${app}/dynos`;
+        }
+        msg += ` on ${color.app(app)}`;
+        ux.action.start(msg);
+        await this.heroku.delete(restartUrl, {
+            headers: {
+                Accept: 'application/vnd.heroku+json; version=3.sdk',
+            },
+        });
+        ux.action.stop();
+    }
+}

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

@@ -0,0 +1,13 @@
+import { Command } from '@heroku-cli/command';
+export default class Scale extends Command {
+    static aliases: string[];
+    static description: string;
+    static examples: 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>;
+}