heroku 8.1.8 → 8.2.0-beta.0

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

@@ -0,0 +1,12 @@
+import { Command } from '@heroku-cli/command';
+export default class Wait 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>;
+        type: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        'wait-interval': import("@oclif/core/lib/interfaces").OptionFlag<number, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        'with-run': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/ps/wait.js

@@ -0,0 +1,78 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+class Wait extends command_1.Command {
+    async run() {
+        const { flags } = await this.parse(Wait);
+        const { body: releases } = await this.heroku.request(`/apps/${flags.app}/releases`, {
+            partial: true,
+            headers: {
+                Range: 'version ..; max=1, order=desc',
+            },
+        });
+        if (releases.length === 0) {
+            this.warn(`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) => {
+                return 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) {
+                    core_1.ux.action.stop(`${releasedFraction}, done`);
+                }
+                break;
+            }
+            if (released) {
+                released = false;
+                core_1.ux.action.start(`Waiting for every dyno to be running v${latestRelease.version}`);
+            }
+            core_1.ux.action.status = releasedFraction;
+            await core_1.ux.wait(interval * 1000);
+        }
+    }
+}
+exports.default = Wait;
+_a = Wait;
+Wait.description = 'wait for all dynos to be running latest version after a release';
+Wait.flags = {
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+    type: command_1.flags.string({
+        char: 't',
+        description: 'wait for one specific dyno type',
+    }),
+    'wait-interval': command_1.flags.integer({
+        char: 'w',
+        description: 'how frequently to poll in seconds (to avoid hitting Heroku API rate limits)',
+        parse: async (input) => {
+            const w = Number.parseInt(input, 10);
+            if (w < 10) {
+                core_1.ux.error('wait-interval must be at least 10', { exit: 1 });
+            }
+            return w;
+        },
+        default: 10,
+    }),
+    'with-run': command_1.flags.boolean({
+        char: 'R',
+        description: 'whether to wait for one-off run dynos',
+        exclusive: ['type'],
+    }),
+};

package/lib/commands/rake.d.ts

@@ -0,0 +1,14 @@
+import { Command } from '@heroku-cli/command';
+export default class RunRake extends Command {
+    static hidden: boolean;
+    static strict: boolean;
+    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>;
+        size: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        'exit-code': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        env: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        'no-tty': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/rake.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// tslint:disable:file-name-casing
+const command_1 = require("@heroku-cli/command");
+const completions_1 = require("@heroku-cli/command/lib/completions");
+const core_1 = require("@oclif/core");
+const dyno_1 = require("../lib/run/dyno");
+const helpers_1 = require("../lib/run/helpers");
+class RunRake extends command_1.Command {
+    async run() {
+        const { flags, argv } = await this.parse(RunRake);
+        const opts = {
+            heroku: this.heroku,
+            app: flags.app,
+            command: (0, helpers_1.buildCommand)(['rake', ...argv]),
+            size: flags.size,
+            'exit-code': flags['exit-code'],
+            env: flags.env,
+            'no-tty': flags['no-tty'],
+            attach: true,
+        };
+        const dyno = new dyno_1.default(opts);
+        try {
+            await dyno.start();
+        }
+        catch (error) {
+            if (error.exitCode) {
+                core_1.ux.error(error, { exit: error.exitCode });
+            }
+            else {
+                throw error;
+            }
+        }
+    }
+}
+exports.default = RunRake;
+RunRake.hidden = true;
+RunRake.strict = false;
+RunRake.flags = {
+    app: command_1.flags.app({ description: 'parent app used by review apps', required: true }),
+    remote: command_1.flags.remote(),
+    size: command_1.flags.string({ char: 's', description: 'dyno size', completion: completions_1.DynoSizeCompletion }),
+    'exit-code': command_1.flags.boolean({ char: 'x', description: 'passthrough the exit code of the remote command' }),
+    env: command_1.flags.string({ char: 'e', description: "environment variables to set (use ';' to split multiple vars)" }),
+    'no-tty': command_1.flags.boolean({ description: 'force the command to not run in a tty' }),
+};

package/lib/commands/regions.d.ts

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

package/lib/commands/regions.js

@@ -0,0 +1,45 @@
+"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 _ = require("lodash");
+class Regions extends command_1.Command {
+    async run() {
+        const { flags } = await this.parse(Regions);
+        let { body: regions } = await this.heroku.get('/regions');
+        if (flags.private) {
+            regions = regions.filter((region) => region.private_capable);
+        }
+        else if (flags.common) {
+            regions = regions.filter((region) => !region.private_capable);
+        }
+        regions = _.sortBy(regions, ['private_capable', 'name']);
+        if (flags.json) {
+            core_1.ux.styledJSON(regions);
+        }
+        else {
+            core_1.ux.table(regions, {
+                name: {
+                    header: 'ID',
+                    get: ({ name }) => color_1.default.green(name),
+                },
+                description: {
+                    header: 'Location',
+                },
+                private_capable: {
+                    header: 'Runtime',
+                    get: ({ private_capable }) => private_capable ? 'Private Spaces' : 'Common Runtime',
+                },
+            });
+        }
+    }
+}
+exports.default = Regions;
+Regions.topic = 'regions';
+Regions.description = 'list available regions for deployment';
+Regions.flags = {
+    json: command_1.flags.boolean({ description: 'output in json format' }),
+    private: command_1.flags.boolean({ description: 'show regions for private spaces' }),
+    common: command_1.flags.boolean({ description: 'show regions for common runtime' }),
+};

package/lib/commands/reviewapps/disable.d.ts

@@ -0,0 +1,17 @@
+import { Command } from '@heroku-cli/command';
+export default class ReviewappsDisable extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        app: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        remote: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        pipeline: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        autodeploy: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        autodestroy: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        'wait-for-ci': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        'no-autodeploy': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        'no-autodestroy': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        'no-wait-for-ci': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/reviewapps/disable.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const kolkrabbi_api_1 = require("../../lib/pipelines/kolkrabbi-api");
+class ReviewappsDisable extends command_1.Command {
+    async run() {
+        const { flags } = await this.parse(ReviewappsDisable);
+        if (flags.app) {
+            // remove app & remote flags when Review Apps 1.0 is deprecated
+            this.warn('Specifying an app via --app or --remote is no longer needed with Review Apps');
+        }
+        const settings = {
+            automatic_review_apps: undefined,
+            destroy_stale_apps: undefined,
+            wait_for_ci: undefined,
+            pipeline: undefined,
+            repo: undefined,
+        };
+        // flags.autodeploy are back supported
+        if (flags['no-autodeploy'] || flags.autodeploy) {
+            this.log('Disabling auto deployment...');
+            settings.automatic_review_apps = false;
+        }
+        // flags.autodestroy are back supported
+        if (flags['no-autodestroy'] || flags.autodestroy) {
+            this.log('Disabling auto destroy...');
+            settings.destroy_stale_apps = false;
+        }
+        // flags['wait-for-ci'] are back supported
+        if (flags['no-wait-for-ci'] || flags['wait-for-ci']) {
+            this.log('Disabling wait for CI...');
+            settings.wait_for_ci = false;
+        }
+        const kolkrabbi = new kolkrabbi_api_1.default(this.config.userAgent, () => this.heroku.auth);
+        core_1.ux.action.start('Configuring pipeline');
+        const { body: pipeline } = await this.heroku.get(`/pipelines/${flags.pipeline}`);
+        settings.pipeline = pipeline.id;
+        try {
+            const { body: feature } = await this.heroku.get('/account/features/dashboard-repositories-api');
+            if (feature.enabled) {
+                const { body: repo } = await this.heroku.get(`/pipelines/${pipeline.id}/repo`, {
+                    headers: { Accept: 'application/vnd.heroku+json; version=3.repositories-api' },
+                });
+                settings.repo = repo.full_name;
+            }
+        }
+        catch (_a) {
+            const { repository } = await kolkrabbi.getPipelineRepository(pipeline.id);
+            settings.repo = repository.name;
+        }
+        if (flags.autodeploy || flags['no-autodeploy'] || flags.autodestroy || flags['no-autodestroy'] || flags['wait-for-ci'] || flags['no-wait-for-ci']) {
+            await this.heroku.patch(`/pipelines/${pipeline.id}/review-app-config`, {
+                body: settings,
+                headers: { Accept: 'application/vnd.heroku+json; version=3.review-apps' },
+            });
+        }
+        else {
+            // if no flags are passed then the user is disabling review apps
+            await this.heroku.delete(`/pipelines/${pipeline.id}/review-app-config`, {
+                body: settings,
+                headers: { Accept: 'application/vnd.heroku+json; version=3.review-apps' },
+            });
+        }
+        core_1.ux.action.stop();
+    }
+}
+exports.default = ReviewappsDisable;
+ReviewappsDisable.description = 'disable review apps and/or settings on an existing pipeline';
+ReviewappsDisable.examples = [
+    '$ heroku reviewapps:disable -p my-pipeline -a my-app --no-autodeploy',
+];
+ReviewappsDisable.flags = {
+    app: command_1.flags.app({
+        description: 'parent app used by review apps',
+    }),
+    remote: command_1.flags.remote(),
+    pipeline: command_1.flags.pipeline({
+        required: true,
+    }),
+    autodeploy: command_1.flags.boolean({
+        description: 'disable autodeployments',
+        hidden: true,
+    }),
+    autodestroy: command_1.flags.boolean({
+        description: 'disable automatically destroying review apps',
+        hidden: true,
+    }),
+    'wait-for-ci': command_1.flags.boolean({
+        description: 'disable wait for CI',
+        hidden: true,
+    }),
+    'no-autodeploy': command_1.flags.boolean({
+        description: 'disable autodeployments',
+    }),
+    'no-autodestroy': command_1.flags.boolean({
+        description: 'disable automatically destroying review apps',
+    }),
+    'no-wait-for-ci': command_1.flags.boolean({
+        description: 'disable wait for CI',
+    }),
+};

package/lib/commands/reviewapps/enable.d.ts

@@ -0,0 +1,14 @@
+import { Command } from '@heroku-cli/command';
+export default class ReviewappsEnable extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        app: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        remote: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        pipeline: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        autodeploy: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        autodestroy: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        'wait-for-ci': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/reviewapps/enable.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const kolkrabbi_api_1 = require("../../lib/pipelines/kolkrabbi-api");
+class ReviewappsEnable extends command_1.Command {
+    async run() {
+        const { flags } = await this.parse(ReviewappsEnable);
+        if (flags.app) {
+            // remove app & remote flags when Review Apps 1.0 is deprecated
+            this.warn('Specifying an app via --app or --remote is no longer needed with Review Apps');
+        }
+        const settings = {
+            automatic_review_apps: undefined,
+            destroy_stale_apps: undefined,
+            wait_for_ci: undefined,
+            pipeline: undefined,
+            repo: undefined,
+        };
+        if (flags.autodeploy) {
+            this.log('Enabling auto deployment...');
+            settings.automatic_review_apps = true;
+        }
+        if (flags.autodestroy) {
+            this.log('Enabling auto destroy...');
+            settings.destroy_stale_apps = true;
+        }
+        if (flags['wait-for-ci']) {
+            this.log('Enabling wait for CI...');
+            settings.wait_for_ci = true;
+        }
+        const kolkrabbi = new kolkrabbi_api_1.default(this.config.userAgent, () => this.heroku.auth);
+        core_1.ux.action.start('Configuring pipeline');
+        const { body: pipeline } = await this.heroku.get(`/pipelines/${flags.pipeline}`);
+        settings.pipeline = pipeline.id;
+        try {
+            const { body: feature } = await this.heroku.get('/account/features/dashboard-repositories-api');
+            if (feature.enabled) {
+                const { body: repo } = await this.heroku.get(`/pipelines/${pipeline.id}/repo`, {
+                    headers: { Accept: 'application/vnd.heroku+json; version=3.repositories-api' },
+                });
+                settings.repo = repo.full_name;
+            }
+        }
+        catch (_a) {
+            const { repository } = await kolkrabbi.getPipelineRepository(pipeline.id);
+            settings.repo = repository.name;
+        }
+        if (flags.autodeploy || flags.autodestroy || flags['wait-for-ci']) {
+            await this.heroku.patch(`/pipelines/${pipeline.id}/review-app-config`, {
+                body: settings,
+                headers: { Accept: 'application/vnd.heroku+json; version=3.review-apps' },
+            });
+        }
+        else {
+            // if no flags are passed then the user is enabling review apps
+            await this.heroku.post(`/pipelines/${pipeline.id}/review-app-config`, {
+                body: settings,
+                headers: { Accept: 'application/vnd.heroku+json; version=3.review-apps' },
+            });
+        }
+        core_1.ux.action.stop();
+    }
+}
+exports.default = ReviewappsEnable;
+ReviewappsEnable.description = 'enable review apps and/or settings on an existing pipeline';
+ReviewappsEnable.examples = [
+    '$ heroku reviewapps:enable -p my-pipeline -a my-app --autodeploy --autodestroy',
+];
+ReviewappsEnable.flags = {
+    app: command_1.flags.app({
+        description: 'parent app used by review apps',
+    }),
+    remote: command_1.flags.remote(),
+    pipeline: command_1.flags.string({
+        char: 'p',
+        description: 'name of pipeline',
+        required: true,
+    }),
+    autodeploy: command_1.flags.boolean({
+        description: 'autodeploy the review app',
+    }),
+    autodestroy: command_1.flags.boolean({
+        description: 'autodestroy the review app',
+    }),
+    'wait-for-ci': command_1.flags.boolean({
+        description: 'wait for CI to pass before deploying',
+    }),
+};

package/lib/commands/run/detached.d.ts

@@ -0,0 +1,15 @@
+import { Command } from '@heroku-cli/command';
+export default class RunDetached extends Command {
+    static description: string;
+    static examples: string[];
+    static strict: boolean;
+    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>;
+        env: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        size: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        tail: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        type: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/run/detached.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+// tslint:disable:file-name-casing
+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 dyno_1 = require("../../lib/run/dyno");
+const helpers_1 = require("../../lib/run/helpers");
+const log_displayer_1 = require("../../lib/run/log-displayer");
+class RunDetached extends command_1.Command {
+    async run() {
+        const { flags, argv } = await this.parse(RunDetached);
+        const opts = {
+            heroku: this.heroku,
+            app: flags.app,
+            command: (0, helpers_1.buildCommand)(argv),
+            size: flags.size,
+            type: flags.type,
+            env: flags.env,
+            attach: false,
+        };
+        if (!opts.command) {
+            throw new Error('Usage: heroku run COMMAND\n\nExample: heroku run bash');
+        }
+        const dyno = new dyno_1.default(opts);
+        await dyno.start();
+        if (flags.tail) {
+            await (0, log_displayer_1.default)(this.heroku, {
+                app: flags.app,
+                // @ts-ignore
+                dyno: dyno.dyno.name,
+                tail: true,
+            });
+        }
+        else {
+            // @ts-ignore
+            core_1.ux.log(`Run ${color_1.default.cmd('heroku logs --app ' + dyno.opts.app + ' --dyno ' + dyno.dyno.name)} to view the output.`);
+        }
+    }
+}
+exports.default = RunDetached;
+RunDetached.description = 'run a detached dyno, where output is sent to your logs';
+RunDetached.examples = [
+    '$ heroku run:detached ls',
+];
+RunDetached.strict = false;
+RunDetached.flags = {
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+    env: command_1.flags.string({ char: 'e', description: "environment variables to set (use ';' to split multiple vars)" }),
+    size: command_1.flags.string({ char: 's', description: 'dyno size', completion: completions_1.DynoSizeCompletion }),
+    tail: command_1.flags.boolean({ char: 't', description: 'continually stream logs' }),
+    type: command_1.flags.string({ description: 'process type', completion: completions_1.ProcessTypeCompletion }),
+};

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

@@ -0,0 +1,18 @@
+import { Command } from '@heroku-cli/command';
+export default class Run extends Command {
+    static description: string;
+    static examples: string[];
+    static strict: boolean;
+    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>;
+        size: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        type: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        'exit-code': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        env: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        'no-tty': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        listen: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        'no-notify': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/run/index.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@heroku-cli/command");
+const completions_1 = require("@heroku-cli/command/lib/completions");
+const core_1 = require("@oclif/core");
+const debug_1 = require("debug");
+const dyno_1 = require("../../lib/run/dyno");
+const helpers_1 = require("../../lib/run/helpers");
+const debug = (0, debug_1.default)('heroku:run');
+class Run extends command_1.Command {
+    async run() {
+        const { argv, flags } = await this.parse(Run);
+        const opts = {
+            'exit-code': flags['exit-code'],
+            'no-tty': flags['no-tty'],
+            app: flags.app,
+            attach: true,
+            command: (0, helpers_1.buildCommand)(argv),
+            env: flags.env,
+            heroku: this.heroku,
+            listen: flags.listen,
+            notify: !flags['no-notify'],
+            size: flags.size,
+            type: flags.type,
+        };
+        if (!opts.command) {
+            throw new Error('Usage: heroku run COMMAND\n\nExample: heroku run bash');
+        }
+        await this.heroku.get('/account');
+        const dyno = new dyno_1.default(opts);
+        try {
+            await dyno.start();
+            debug('done running');
+        }
+        catch (error) {
+            debug(error);
+            if (error.exitCode) {
+                core_1.ux.error(error.message, { code: error.exitCode, exit: error.exitCode });
+            }
+            else {
+                throw error;
+            }
+        }
+    }
+}
+exports.default = Run;
+Run.description = 'run a one-off process inside a heroku dyno\nShows a notification if the dyno takes more than 20 seconds to start.';
+Run.examples = [
+    '$ heroku run bash',
+    '$ heroku run -s standard-2x -- myscript.sh -a arg1 -s arg2',
+];
+// This is to allow for variable length arguments
+Run.strict = false;
+Run.flags = {
+    app: command_1.flags.app({ description: 'parent app used by review apps', required: true }),
+    remote: command_1.flags.remote(),
+    size: command_1.flags.string({ char: 's', description: 'dyno size', completion: completions_1.DynoSizeCompletion }),
+    type: command_1.flags.string({ description: 'process type', completion: completions_1.ProcessTypeCompletion }),
+    'exit-code': command_1.flags.boolean({ char: 'x', description: 'passthrough the exit code of the remote command' }),
+    env: command_1.flags.string({ char: 'e', description: "environment variables to set (use ';' to split multiple vars)" }),
+    'no-tty': command_1.flags.boolean({ description: 'force the command to not run in a tty' }),
+    listen: command_1.flags.boolean({ description: 'listen on a local port', hidden: true }),
+    'no-notify': command_1.flags.boolean({ description: 'disables notification when dyno is up (alternatively use HEROKU_NOTIFICATIONS=0)' }),
+};

package/lib/commands/run/inside.d.ts

@@ -0,0 +1,15 @@
+import { Command } from '@heroku-cli/command';
+export default class RunInside extends Command {
+    static description: string;
+    static hidden: boolean;
+    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>;
+        'exit-code': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        env: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        listen: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    static strict: boolean;
+    run(): Promise<void>;
+}