heroku 8.1.9 → 8.2.0-beta.0

package/lib/commands/pipelines/promote.js

@@ -0,0 +1,216 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sleep = void 0;
+const color_1 = require("@heroku-cli/color");
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const assert = require("assert");
+const node_fetch_1 = require("node-fetch");
+const Stream = require("stream");
+const util = require("util");
+const api_1 = require("../../lib/pipelines/api");
+const key_by_1 = require("../../lib/pipelines/key-by");
+const sleep = (time) => {
+    return new Promise(resolve => setTimeout(resolve, time));
+};
+exports.sleep = sleep;
+function assertNotPromotingToSelf(source, target) {
+    assert.notStrictEqual(source, target, `Cannot promote from an app to itself: ${target}. Specify a different target app.`);
+}
+function findAppInPipeline(apps, target) {
+    const found = apps.find(app => (app.name === target) || (app.id === target));
+    assert(found, `Cannot find app ${color_1.default.app(target)}`);
+    return found;
+}
+const PROMOTION_ORDER = ['development', 'staging', 'production'];
+const wait = (ms = 100) => new Promise(resolve => setTimeout(resolve, ms));
+function isComplete(promotionTarget) {
+    return promotionTarget.status !== 'pending';
+}
+function isSucceeded(promotionTarget) {
+    return promotionTarget.status === 'succeeded';
+}
+function isFailed(promotionTarget) {
+    return promotionTarget.status === 'failed';
+}
+function pollPromotionStatus(heroku, id, needsReleaseCommand) {
+    return heroku.get(`/pipeline-promotions/${id}/promotion-targets`).then(function ({ body: targets }) {
+        if (targets.every(isComplete)) { // eslint-disable-line unicorn/no-array-callback-reference
+            return targets;
+        }
+        //
+        // With only one target, we can return as soon as the release is created.
+        // The command will then read the release phase output
+        //
+        // `needsReleaseCommand` allows us to keep polling, as it can take a few
+        // seconds to get the release to succeeded after the release command
+        // finished.
+        //
+        if (needsReleaseCommand && targets.length === 1 && targets[0].release !== null) {
+            return targets;
+        }
+        return wait(1000).then(pollPromotionStatus.bind(null, heroku, id, needsReleaseCommand));
+    });
+}
+async function getCoupling(heroku, app) {
+    core_1.ux.log('Fetching app info...');
+    const { body: coupling } = await heroku.get(`/apps/${app}/pipeline-couplings`);
+    return coupling;
+}
+async function promote(heroku, label, id, sourceAppId, targetApps, secondFactor) {
+    const options = {
+        headers: {},
+        body: {
+            pipeline: { id },
+            source: { app: { id: sourceAppId } },
+            targets: targetApps.map(app => ({ app: { id: app.id } })),
+        },
+    };
+    if (secondFactor) {
+        options.headers = { 'Heroku-Two-Factor-Code': secondFactor };
+    }
+    try {
+        core_1.ux.log(`${label}...`);
+        const { body: promotions } = await heroku.post('/pipeline-promotions', options);
+        return promotions;
+    }
+    catch (error) {
+        if (!error.body || error.body.id !== 'two_factor') {
+            throw error;
+        }
+        const secondFactor = await heroku.twoFactorPrompt();
+        return promote(heroku, label, id, sourceAppId, targetApps, secondFactor);
+    }
+}
+function assertValidPromotion(app, source, target) {
+    if (!target || PROMOTION_ORDER.indexOf(source) < 0) { // eslint-disable-line unicorn/prefer-includes
+        throw new Error(`Cannot promote ${app} from '${source}' stage`);
+    }
+}
+function assertApps(app, targetApps, targetStage) {
+    if (targetApps.length === 0) {
+        throw new Error(`Cannot promote from ${color_1.default.app(app)} as there are no downstream apps in ${targetStage} stage`);
+    }
+}
+async function getRelease(heroku, app, releaseId) {
+    core_1.ux.log('Fetching release info...');
+    const { body: release } = await heroku.get(`/apps/${app}/releases/${releaseId}`);
+    return release;
+}
+async function streamReleaseCommand(heroku, targets, promotion) {
+    if (targets.length !== 1 || targets.every(isComplete)) { // eslint-disable-line unicorn/no-array-callback-reference
+        return pollPromotionStatus(heroku, promotion.id, false);
+    }
+    const target = targets[0];
+    const release = await getRelease(heroku, target.app.id, target.release.id);
+    if (!release.output_stream_url) {
+        return pollPromotionStatus(heroku, promotion.id, false);
+    }
+    core_1.ux.log('Running release command...');
+    async function streamReleaseOutput(releaseStreamUrl) {
+        const finished = util.promisify(Stream.finished);
+        const fetchResponse = await (0, node_fetch_1.default)(releaseStreamUrl);
+        if (fetchResponse.status >= 400) {
+            throw new Error('stream release output not available');
+        }
+        fetchResponse.body.pipe(process.stdout);
+        await finished(fetchResponse.body);
+    }
+    async function retry(maxAttempts, fn) {
+        let currentAttempt = 0;
+        while (true) {
+            try {
+                await fn();
+                return;
+            }
+            catch (error) {
+                if (++currentAttempt === maxAttempts) {
+                    throw error;
+                }
+                await (0, exports.sleep)(1000);
+            }
+        }
+    }
+    await retry(100, () => {
+        return streamReleaseOutput(release.output_stream_url);
+    });
+    return pollPromotionStatus(heroku, promotion.id, false);
+}
+class Promote extends command_1.Command {
+    async run() {
+        const { flags } = await this.parse(Promote);
+        const appNameOrId = flags.app;
+        const coupling = await getCoupling(this.heroku, appNameOrId);
+        core_1.ux.log(`Fetching apps from ${color_1.default.pipeline(coupling.pipeline.name)}...`);
+        const allApps = await (0, api_1.listPipelineApps)(this.heroku, coupling.pipeline.id);
+        const sourceStage = coupling.stage;
+        let promotionActionName = '';
+        let targetApps = [];
+        if (flags.to) {
+            // The user specified a specific set of apps they want to target
+            // We don't have to infer the apps or the stage they want to promote to
+            // Strip out any empty app names due to something like a trailing comma
+            const targetAppNames = flags.to.split(',').filter(appName => appName.length > 0);
+            // Now let's make sure that we can find every target app they specified
+            // The only requirement is that the app be in this pipeline. They can be at any stage.
+            targetApps = targetAppNames.reduce((acc, targetAppNameOrId) => {
+                assertNotPromotingToSelf(appNameOrId, targetAppNameOrId);
+                const app = findAppInPipeline(allApps, targetAppNameOrId);
+                if (app) {
+                    acc.push(app);
+                }
+                return acc;
+            }, []);
+            promotionActionName = `Starting promotion to apps: ${targetAppNames.toString()}`;
+        }
+        else {
+            const targetStage = PROMOTION_ORDER[PROMOTION_ORDER.indexOf(sourceStage) + 1];
+            assertValidPromotion(appNameOrId, sourceStage, targetStage);
+            targetApps = allApps.filter(app => app.coupling.stage === targetStage);
+            assertApps(appNameOrId, targetApps, targetStage);
+            promotionActionName = `Starting promotion to ${targetStage}`;
+        }
+        const promotion = await promote(this.heroku, promotionActionName, coupling.pipeline.id, coupling.app.id, targetApps);
+        const pollLoop = pollPromotionStatus(this.heroku, promotion.id, true);
+        core_1.ux.log('Waiting for promotion to complete...');
+        let promotionTargets = await pollLoop;
+        try {
+            promotionTargets = await streamReleaseCommand(this.heroku, promotionTargets, promotion);
+        }
+        catch (error) {
+            core_1.ux.error(error);
+        }
+        const appsByID = (0, key_by_1.default)(allApps, 'id');
+        const styledTargets = promotionTargets.reduce(function (memo, target) {
+            const app = appsByID[target.app.id];
+            const details = [target.status];
+            if (isFailed(target)) {
+                details.push(target.error_message);
+            }
+            memo[app.name] = details;
+            return memo;
+        }, {});
+        if (promotionTargets.every(isSucceeded)) { // eslint-disable-line unicorn/no-array-callback-reference
+            core_1.ux.log('\nPromotion successful');
+        }
+        else {
+            core_1.ux.warn('\nPromotion to some apps failed');
+        }
+        core_1.ux.styledObject(styledTargets);
+    }
+}
+exports.default = Promote;
+Promote.description = 'promote the latest release of this app to its downstream app(s)';
+Promote.examples = [
+    '$ heroku pipelines:promote -a my-app-staging',
+];
+Promote.flags = {
+    app: command_1.flags.app({
+        required: true,
+    }),
+    remote: command_1.flags.remote(),
+    to: command_1.flags.string({
+        char: 't',
+        description: 'comma separated list of apps to promote to',
+    }),
+};

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

@@ -0,0 +1,10 @@
+import { Command } from '@heroku-cli/command';
+export default class PipelinesRemove extends Command {
+    static description: string;
+    static examples: 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/pipelines/remove.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const color_1 = require("@heroku-cli/color");
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const api_1 = require("../../lib/pipelines/api");
+class PipelinesRemove extends command_1.Command {
+    async run() {
+        const { flags: { app } } = await this.parse(PipelinesRemove);
+        core_1.ux.action.start(`Removing ${color_1.default.app(app)}`);
+        await (0, api_1.removeCoupling)(this.heroku, app);
+        core_1.ux.action.stop();
+    }
+}
+exports.default = PipelinesRemove;
+PipelinesRemove.description = 'remove this app from its pipeline';
+PipelinesRemove.examples = [
+    '$ heroku pipelines:remove -a my-app',
+];
+PipelinesRemove.flags = {
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+};

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

@@ -0,0 +1,10 @@
+import { Command } from '@heroku-cli/command';
+export default class PipelinesRename extends Command {
+    static description: string;
+    static examples: string[];
+    static args: {
+        pipeline: import("@oclif/core/lib/interfaces/parser").Arg<string, Record<string, unknown>>;
+        name: import("@oclif/core/lib/interfaces/parser").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/pipelines/rename.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const color_1 = require("@heroku-cli/color");
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const api_1 = require("../../lib/pipelines/api");
+const disambiguate_1 = require("../../lib/pipelines/disambiguate");
+class PipelinesRename extends command_1.Command {
+    async run() {
+        const { args } = await this.parse(PipelinesRename);
+        const pipeline = await (0, disambiguate_1.default)(this.heroku, args.pipeline);
+        core_1.ux.action.start(`Renaming ${color_1.default.pipeline(pipeline.name)} pipeline to ${color_1.default.pipeline(args.name)}`);
+        await (0, api_1.updatePipeline)(this.heroku, pipeline.id, {
+            name: args.name,
+        });
+        core_1.ux.action.stop();
+    }
+}
+exports.default = PipelinesRename;
+PipelinesRename.description = 'rename a pipeline';
+PipelinesRename.examples = [
+    '$ heroku pipelines:rename my-pipeline new-pipeline-name',
+];
+PipelinesRename.args = {
+    pipeline: core_1.Args.string({
+        description: 'current name of pipeline',
+        required: true,
+    }),
+    name: core_1.Args.string({
+        description: 'new name of pipeline',
+        required: true,
+    }),
+};

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

@@ -0,0 +1,14 @@
+import { Command } from '@heroku-cli/command';
+export default class Setup extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        team: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        yes: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    static args: {
+        name: import("@oclif/core/lib/interfaces/parser").Arg<string | undefined, Record<string, unknown>>;
+        repo: import("@oclif/core/lib/interfaces/parser").Arg<string | undefined, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/pipelines/setup.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const color_1 = require("@heroku-cli/color");
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const open = require("open");
+const debug_1 = require("debug");
+const api_1 = require("../../lib/pipelines/api");
+const github_api_1 = require("../../lib/pipelines/github-api");
+const kolkrabbi_api_1 = require("../../lib/pipelines/kolkrabbi-api");
+const create_apps_1 = require("../../lib/pipelines/setup/create-apps");
+const get_ci_settings_1 = require("../../lib/pipelines/setup/get-ci-settings");
+const get_github_token_1 = require("../../lib/pipelines/setup/get-github-token");
+const get_name_and_repo_1 = require("../../lib/pipelines/setup/get-name-and-repo");
+const get_repo_1 = require("../../lib/pipelines/setup/get-repo");
+const get_settings_1 = require("../../lib/pipelines/setup/get-settings");
+const poll_app_setups_1 = require("../../lib/pipelines/setup/poll-app-setups");
+const setup_pipeline_1 = require("../../lib/pipelines/setup/setup-pipeline");
+const validate_1 = require("../../lib/pipelines/setup/validate");
+// eslint-disable-next-line new-cap
+const debug = (0, debug_1.default)('pipelines:setup');
+class Setup extends command_1.Command {
+    async run() {
+        const { args, flags } = await this.parse(Setup);
+        const errors = (0, validate_1.nameAndRepo)(args);
+        if (errors.length > 0) {
+            this.error(errors.join(', '));
+            return;
+        }
+        const kolkrabbi = new kolkrabbi_api_1.default(this.config.userAgent, () => this.heroku.auth);
+        const github = new github_api_1.default(this.config.userAgent, await (0, get_github_token_1.default)(kolkrabbi));
+        const team = flags.team;
+        const { name: pipelineName, repo: repoName } = await (0, get_name_and_repo_1.default)(args);
+        const stagingAppName = pipelineName + validate_1.STAGING_APP_INDICATOR;
+        const repo = await (0, get_repo_1.default)(github, repoName);
+        const settings = await (0, get_settings_1.default)(flags.yes, repo.default_branch);
+        const ciSettings = await (0, get_ci_settings_1.default)(flags.yes, team);
+        const ownerType = team ? 'team' : 'user';
+        // If team or org is not specified, we assign ownership to the user creating
+        const { body: { id: ownerID }, } = team ? await (0, api_1.getTeam)(this.heroku, team) : await (0, api_1.getAccountInfo)(this.heroku);
+        const owner = { id: ownerID, type: ownerType };
+        core_1.ux.action.start('Creating pipeline');
+        const { body: pipeline } = await (0, api_1.createPipeline)(this.heroku, pipelineName, owner);
+        core_1.ux.action.stop();
+        core_1.ux.action.start('Linking to repo');
+        await kolkrabbi.createPipelineRepository(pipeline.id, repo.id);
+        core_1.ux.action.stop();
+        const archiveURL = await kolkrabbi.getArchiveURL(repoName, repo.default_branch);
+        const appSetupsResult = await (0, create_apps_1.default)(this.heroku, archiveURL, pipeline, pipelineName, stagingAppName, team);
+        const appSetups = appSetupsResult.map((result) => result.body);
+        core_1.ux.action.start(`Creating production and staging apps (${color_1.default.app(pipelineName)} and ${color_1.default.app(stagingAppName)})`);
+        await (0, poll_app_setups_1.default)(this.heroku, appSetups);
+        core_1.ux.action.stop();
+        const stagingApp = appSetups.find((appSetup) => appSetup.app.name === stagingAppName).app;
+        const setup = (0, setup_pipeline_1.default)(kolkrabbi, stagingApp.id, settings, pipeline.id, ciSettings);
+        core_1.ux.action.start('Configuring pipeline');
+        try {
+            await setup;
+            await open(`https://dashboard.heroku.com/pipelines/${pipeline.id}`);
+        }
+        catch (error) {
+            debug(error);
+            core_1.ux.error(error);
+        }
+        finally {
+            core_1.ux.action.stop();
+        }
+    }
+}
+exports.default = Setup;
+Setup.description = 'bootstrap a new pipeline with common settings and create a production and staging app (requires a fully formed app.json in the repo)';
+Setup.examples = ['$ heroku pipelines:setup my-pipeline githuborg/reponame -t my-team'];
+Setup.flags = {
+    team: command_1.flags.team({
+        description: 'the team to assign pipeline ownership to (defaults to current user)',
+    }),
+    yes: command_1.flags.boolean({
+        char: 'y',
+        description: 'accept all default settings without prompting',
+    }),
+};
+Setup.args = {
+    name: core_1.Args.string({
+        description: 'name of pipeline',
+        required: false,
+    }),
+    repo: core_1.Args.string({
+        description: 'a GitHub repository to connect the pipeline to',
+        required: false,
+    }),
+};

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

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

package/lib/commands/pipelines/transfer.js

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

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/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>;
+        stage: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/pipelines/update.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const color_1 = require("@heroku-cli/color");
+const command_1 = require("@heroku-cli/command");
+const completions_1 = require("@heroku-cli/command/lib/completions");
+const core_1 = require("@oclif/core");
+const api_1 = require("../../lib/pipelines/api");
+class PipelinesUpdate extends command_1.Command {
+    async run() {
+        const { flags } = await this.parse(PipelinesUpdate);
+        const app = flags.app;
+        const stage = flags.stage;
+        core_1.ux.action.start(`Changing ${color_1.default.app(app)} to ${stage}`);
+        await (0, api_1.updateCoupling)(this.heroku, app, stage);
+        core_1.ux.action.stop();
+    }
+}
+exports.default = PipelinesUpdate;
+PipelinesUpdate.description = 'update the app\'s stage in a pipeline';
+PipelinesUpdate.examples = [
+    '$ heroku pipelines:update -s staging -a my-app',
+];
+PipelinesUpdate.flags = {
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+    stage: command_1.flags.string({
+        char: 's',
+        description: 'new stage of app',
+        completion: completions_1.StageCompletion,
+        required: true,
+    }),
+};

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

@@ -0,0 +1,9 @@
+import { Command } from '@heroku-cli/command';
+export default class Disable extends Command {
+    static description: 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/autoscale/disable.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const METRICS_HOST = 'api.metrics.heroku.com';
+class Disable extends command_1.Command {
+    async run() {
+        const { flags } = await this.parse(Disable);
+        core_1.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',
+            },
+        });
+        core_1.ux.action.stop();
+    }
+}
+exports.default = Disable;
+Disable.description = 'disable web dyno autoscaling';
+Disable.flags = {
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+};

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

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

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

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const METRICS_HOST = 'api.metrics.heroku.com';
+const isPerfOrPrivateTier = (size) => {
+    const applicableTiers = ['performance', 'private', 'shield'];
+    return applicableTiers.some(tier => size.toLowerCase().includes(tier));
+};
+class Enable extends command_1.Command {
+    async run() {
+        const { flags } = await this.parse(Enable);
+        core_1.ux.action.start('Enabling dyno autoscaling');
+        const [appResponse, formationResponse] = await Promise.all([
+            this.heroku.get(`/apps/${flags.app}`),
+            this.heroku.get(`/apps/${flags.app}/formation`),
+        ]);
+        const app = appResponse.body;
+        const formations = formationResponse.body;
+        const webFormation = formations.find((f) => f.type === 'web');
+        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 = Object.assign(Object.assign({}, updatedValues), { min_quantity: flags.min || scaleMonitor.min_quantity, max_quantity: flags.max || scaleMonitor.max_quantity, value: flags.p95 ? flags.p95 : scaleMonitor.value });
+            await this.heroku.patch(`/apps/${app.id}/formation/web/monitors/${scaleMonitor.id}`, {
+                body: updatedValues,
+                hostname: METRICS_HOST,
+            });
+        }
+        else {
+            updatedValues = Object.assign(Object.assign({}, updatedValues), { name: 'LATENCY_SCALE', min_quantity: flags.min, max_quantity: flags.max, value: flags.p95 ? flags.p95 : 1000 });
+            await this.heroku.post(`/apps/${app.id}/formation/web/monitors`, {
+                hostname: METRICS_HOST,
+                body: updatedValues,
+            });
+        }
+        core_1.ux.action.stop();
+    }
+}
+exports.default = Enable;
+Enable.description = 'enable web dyno autoscaling';
+Enable.flags = {
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+    min: command_1.flags.integer({ required: true, description: 'minimum number of dynos' }),
+    max: command_1.flags.integer({ required: true, description: 'maximum number of dynos' }),
+    p95: command_1.flags.integer({ description: 'desired p95 response time' }),
+    notifications: command_1.flags.boolean({ description: 'receive email notifications when the max dyno limit is reached' }),
+};