heroku 9.0.0-dev.0 → 9.0.0

package/lib/commands/addons/services.js

@@ -0,0 +1,34 @@
+"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");
+class Services extends command_1.Command {
+    async run() {
+        const { flags } = await this.parse(Services);
+        const { body: services } = await this.heroku.get('/addon-services');
+        if (flags.json) {
+            core_1.ux.styledJSON(services);
+        }
+        else {
+            core_1.ux.table(services, {
+                name: {
+                    header: 'Slug',
+                },
+                human_name: {
+                    header: 'Name',
+                },
+                state: {
+                    header: 'State',
+                },
+            });
+            core_1.ux.log(`\nSee plans with ${color_1.default.blue('heroku addons:plans SERVICE')}`);
+        }
+    }
+}
+exports.default = Services;
+Services.topic = 'addons';
+Services.description = 'list all available add-on services';
+Services.flags = {
+    json: command_1.flags.boolean({ description: 'output in json format' }),
+};

package/lib/commands/addons/upgrade.d.ts

@@ -0,0 +1,28 @@
+import { Command } from '@heroku-cli/command';
+import type { Plan } from '@heroku-cli/schema';
+export default class Upgrade extends Command {
+    static aliases: string[];
+    static topic: string;
+    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>;
+    };
+    static args: {
+        addon: import("@oclif/core/lib/interfaces/parser").Arg<string, Record<string, unknown>>;
+        plan: import("@oclif/core/lib/interfaces/parser").Arg<string | undefined, Record<string, unknown>>;
+    };
+    private parsed;
+    run(): Promise<void>;
+    protected getAddonPartsFromArgs(args: {
+        addon: string;
+        plan: string | undefined;
+    }): {
+        plan: string;
+        addon: string;
+    };
+    protected buildNoPlanError(addon: string): string;
+    protected buildApiErrorMessage(errorMessage: string, ctx: Awaited<typeof this.parsed>): string;
+    protected getPlans(addonServiceName: string | undefined): Promise<Plan[]>;
+}

package/lib/commands/addons/upgrade.js

@@ -0,0 +1,145 @@
+"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 util_1 = require("../../lib/addons/util");
+const resolve_1 = require("../../lib/addons/resolve");
+const api_client_1 = require("@heroku-cli/command/lib/api-client");
+class Upgrade extends command_1.Command {
+    constructor() {
+        super(...arguments);
+        this.parsed = this.parse(Upgrade);
+    }
+    async run() {
+        var _a, _b;
+        const ctx = await this.parsed;
+        const { flags: { app }, args } = ctx;
+        // called with just one argument in the form of `heroku addons:upgrade heroku-redis:hobby`
+        const { addon, plan } = this.getAddonPartsFromArgs(args);
+        let resolvedAddon;
+        try {
+            resolvedAddon = await (0, resolve_1.addonResolver)(this.heroku, app, addon);
+        }
+        catch (error) {
+            if (error instanceof api_client_1.HerokuAPIError && error.http.statusCode === 422 && error.body.id === 'multiple_matches') {
+                throw new Error(this.buildApiErrorMessage(error.http.body.message, ctx));
+            }
+            throw error;
+        }
+        const { name: addonServiceName } = resolvedAddon.addon_service;
+        const { name: appName } = resolvedAddon.app;
+        const { name: addonName, plan: resolvedAddonPlan } = resolvedAddon !== null && resolvedAddon !== void 0 ? resolvedAddon : {};
+        const updatedPlanName = `${addonServiceName}:${plan}`;
+        core_1.ux.action.start(`Changing ${color_1.default.magenta(addonName !== null && addonName !== void 0 ? addonName : '')} on ${color_1.default.cyan(appName !== null && appName !== void 0 ? appName : '')} from ${color_1.default.blue((_a = resolvedAddonPlan === null || resolvedAddonPlan === void 0 ? void 0 : resolvedAddonPlan.name) !== null && _a !== void 0 ? _a : '')} to ${color_1.default.blue(updatedPlanName)}`);
+        try {
+            const patchResult = await this.heroku.patch(`/apps/${appName}/addons/${addonName}`, {
+                body: { plan: { name: updatedPlanName } },
+                headers: {
+                    'Accept-Expansion': 'plan', 'X-Heroku-Legacy-Provider-Messages': 'true',
+                },
+            });
+            resolvedAddon = patchResult.body;
+        }
+        catch (error) {
+            let errorToThrow = error;
+            if (error instanceof api_client_1.HerokuAPIError) {
+                const { http } = error;
+                if (http.statusCode === 422 &&
+                    http.body.message &&
+                    http.body.message.startsWith('Couldn\'t find either the add-on')) {
+                    const plans = await this.getPlans(addonServiceName);
+                    errorToThrow = new Error(`${http.body.message}
+
+Here are the available plans for ${color_1.default.yellow(addonServiceName || '')}:
+${plans.map(plan => plan.name).join('\n')}\n\nSee more plan information with ${color_1.default.blue('heroku addons:plans ' + addonServiceName)}
+
+${color_1.default.cyan('https://devcenter.heroku.com/articles/managing-add-ons')}`);
+                }
+                core_1.ux.action.stop();
+                throw errorToThrow;
+            }
+        }
+        core_1.ux.action.stop(`done${((_b = resolvedAddon.plan) === null || _b === void 0 ? void 0 : _b.price) ? `, ${(0, util_1.formatPriceText)(resolvedAddon.plan.price)}` : ''}`);
+        if (resolvedAddon.provision_message) {
+            core_1.ux.log(resolvedAddon.provision_message);
+        }
+    }
+    getAddonPartsFromArgs(args) {
+        let { addon, plan } = args;
+        if (!plan && addon.includes(':')) {
+            ([addon, plan] = addon.split(':'));
+        }
+        if (!plan) {
+            throw new Error(this.buildNoPlanError(addon));
+        }
+        // ignore the service part of the plan since we can infer the service based on the add-on
+        if (plan.includes(':')) {
+            plan = plan.split(':')[1];
+        }
+        return { plan, addon };
+    }
+    buildNoPlanError(addon) {
+        return `Error: No plan specified.
+You need to specify a plan to move ${color_1.default.yellow(addon)} to.
+For example: ${color_1.default.blue('heroku addons:upgrade heroku-redis:premium-0')}
+${color_1.default.cyan('https://devcenter.heroku.com/articles/managing-add-ons')}`;
+    }
+    buildApiErrorMessage(errorMessage, ctx) {
+        const { flags: { app }, args: { addon, plan } } = ctx;
+        const example = errorMessage.split(', ')[2] || 'redis-triangular-1234';
+        return `${errorMessage}
+
+Multiple add-ons match ${color_1.default.yellow(addon)}${app ? ' on ' + app : ''}
+It is not clear which add-on's plan you are trying to change.
+
+Specify the add-on name instead of the name of the add-on service.
+For example, instead of: ${color_1.default.blue('heroku addons:upgrade ' + addon + ' ' + (plan || ''))}
+Run this: ${color_1.default.blue('heroku addons:upgrade ' + example + ' ' + addon + ':' + plan)}
+${app ? '' : 'Alternatively, specify an app to filter by with ' + color_1.default.blue('--app')}
+${color_1.default.cyan('https://devcenter.heroku.com/articles/managing-add-ons')}`;
+    }
+    async getPlans(addonServiceName) {
+        try {
+            const plansResponse = await this.heroku.get(`/addon-services/${addonServiceName}/plans`);
+            const { body: plans } = plansResponse;
+            plans.sort((a, b) => {
+                var _a, _b, _c, _d;
+                if (((_a = a === null || a === void 0 ? void 0 : a.price) === null || _a === void 0 ? void 0 : _a.cents) === ((_b = b === null || b === void 0 ? void 0 : b.price) === null || _b === void 0 ? void 0 : _b.cents)) {
+                    return 0;
+                }
+                if (!((_c = a === null || a === void 0 ? void 0 : a.price) === null || _c === void 0 ? void 0 : _c.cents) || !((_d = b === null || b === void 0 ? void 0 : b.price) === null || _d === void 0 ? void 0 : _d.cents) || a.price.cents > b.price.cents) {
+                    return 1;
+                }
+                if (a.price.cents < b.price.cents) {
+                    return -1;
+                }
+                return 0;
+            });
+            return plans;
+        }
+        catch (_a) {
+            return [];
+        }
+    }
+}
+exports.default = Upgrade;
+Upgrade.aliases = ['addons:downgrade'];
+Upgrade.topic = 'addons';
+Upgrade.description = `change add-on plan.
+  See available plans with \`heroku addons:plans SERVICE\`.
+
+  Note that \`heroku addons:upgrade\` and \`heroku addons:downgrade\` are the same.\
+  Either one can be used to change an add-on plan up or down.
+
+  https://devcenter.heroku.com/articles/managing-add-ons
+  `;
+Upgrade.examples = ['Upgrade an add-on by service name:\n$ heroku addons:upgrade heroku-redis:premium-2\n\nUpgrade a specific add-on:\n$ heroku addons:upgrade swimming-briskly-123 heroku-redis:premium-2'];
+Upgrade.flags = {
+    app: command_1.flags.app(),
+    remote: command_1.flags.remote(),
+};
+Upgrade.args = {
+    addon: core_1.Args.string({ required: true }),
+    plan: core_1.Args.string(),
+};

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

@@ -0,0 +1,14 @@
+import { Command } from '@heroku-cli/command';
+export default class Wait extends Command {
+    static topic: string;
+    static description: string;
+    static flags: {
+        'wait-interval': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        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>;
+    };
+    static args: {
+        addon: import("@oclif/core/lib/interfaces/parser").Arg<string | undefined, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/addons/wait.js

@@ -0,0 +1,70 @@
+"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 resolve_1 = require("../../lib/addons/resolve");
+const addons_wait_1 = require("../../lib/addons/addons_wait");
+const notify_1 = require("../../lib/notify");
+class Wait extends command_1.Command {
+    async run() {
+        const { flags, args } = await this.parse(Wait);
+        let addonsToWaitFor;
+        if (args.addon) {
+            addonsToWaitFor = [await (0, resolve_1.resolveAddon)(this.heroku, flags.app, args.addon)];
+        }
+        else if (flags.app) {
+            const { body: addons } = await this.heroku.get(`/apps/${flags.app}/addons`);
+            addonsToWaitFor = addons;
+        }
+        else {
+            const { body: addons } = await this.heroku.get('/addons');
+            addonsToWaitFor = addons;
+        }
+        addonsToWaitFor = addonsToWaitFor.filter((addon) => addon.state === 'provisioning' || addon.state === 'deprovisioning');
+        let interval = Number.parseInt(flags['wait-interval'] || '', 10);
+        if (!interval || interval < 0) {
+            interval = 5;
+        }
+        for (const addon of addonsToWaitFor) {
+            const startTime = new Date();
+            const addonName = addon.name || '';
+            if (addon.state === 'provisioning') {
+                let addonResponse;
+                try {
+                    addonResponse = await (0, addons_wait_1.waitForAddonProvisioning)(this.heroku, addon, interval);
+                }
+                catch (error) {
+                    (0, notify_1.default)(`heroku addons:wait ${addonName}`, 'Add-on failed to provision', false);
+                    throw error;
+                }
+                const configVars = (addonResponse.config_vars || []);
+                if (configVars.length > 0) {
+                    const decoratedConfigVars = configVars.map(c => color_1.default.green(c))
+                        .join(', ');
+                    core_1.ux.log(`Created ${color_1.default.yellow(addonName)} as ${decoratedConfigVars}`);
+                }
+                if (Date.now() - startTime.valueOf() >= 1000 * 5) {
+                    (0, notify_1.default)(`heroku addons:wait ${addonName}`, 'Add-on successfully provisioned');
+                }
+            }
+            else if (addon.state === 'deprovisioning') {
+                await (0, addons_wait_1.waitForAddonDeprovisioning)(this.heroku, addon, interval);
+                if (Date.now() - startTime.valueOf() >= 1000 * 5) {
+                    (0, notify_1.default)(`heroku addons:wait ${addonName}`, 'Add-on successfully deprovisioned');
+                }
+            }
+        }
+    }
+}
+exports.default = Wait;
+Wait.topic = 'addons';
+Wait.description = 'show provisioning status of the add-ons on the app';
+Wait.flags = {
+    'wait-interval': command_1.flags.string({ description: 'how frequently to poll in seconds' }),
+    app: command_1.flags.app(),
+    remote: command_1.flags.remote(),
+};
+Wait.args = {
+    addon: core_1.Args.string(),
+};

package/lib/commands/apps/create.d.ts

@@ -0,0 +1,28 @@
+import { Command } from '@heroku-cli/command';
+import { Interfaces } from '@oclif/core';
+export default class Create extends Command {
+    static description: string;
+    static hiddenAliases: string[];
+    static examples: string[];
+    static args: {
+        app: import("@oclif/core/lib/interfaces/parser").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        app: Interfaces.OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        addons: Interfaces.OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        buildpack: Interfaces.OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        manifest: Interfaces.BooleanFlag<boolean>;
+        'no-remote': Interfaces.BooleanFlag<boolean>;
+        remote: Interfaces.OptionFlag<string, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        stack: Interfaces.OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        space: Interfaces.OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        region: Interfaces.OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        'internal-routing': Interfaces.BooleanFlag<boolean>;
+        features: Interfaces.OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        kernel: Interfaces.OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        locked: Interfaces.BooleanFlag<boolean>;
+        json: Interfaces.BooleanFlag<boolean>;
+        team: Interfaces.OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/apps/create.js

@@ -0,0 +1,201 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const yaml = require("js-yaml");
+const fs_extra_1 = require("fs-extra");
+const command_1 = require("@heroku-cli/command");
+const completions_1 = require("@heroku-cli/command/lib/completions");
+const core_1 = require("@oclif/core");
+const color_1 = require("@heroku-cli/color");
+const lodash_1 = require("lodash");
+const git_1 = require("../../lib/git/git");
+const git = new git_1.default();
+function createText(name, space) {
+    let text = `Creating ${name ? color_1.default.app(name) : 'app'}`;
+    if (space) {
+        text += ` in space ${space}`;
+    }
+    return text;
+}
+async function createApp(context, heroku, name, stack) {
+    var _a, _b;
+    const { flags } = context;
+    const params = {
+        name,
+        team: flags.team,
+        region: flags.region,
+        space: flags.space,
+        stack,
+        internal_routing: flags['internal-routing'],
+        feature_flags: flags.features,
+        kernel: flags.kernel,
+        locked: flags.locked,
+    };
+    const requestPath = (params.space || params.team) ? '/teams/apps' : '/apps';
+    const { body: app } = await heroku.post(requestPath, {
+        body: params,
+    });
+    let status = name ? 'done' : `done, ${color_1.default.app(app.name || '')}`;
+    if (flags.region) {
+        status += `, region is ${color_1.default.yellow(((_a = app.region) === null || _a === void 0 ? void 0 : _a.name) || '')}`;
+    }
+    if (stack) {
+        status += `, stack is ${color_1.default.yellow(((_b = app.stack) === null || _b === void 0 ? void 0 : _b.name) || '')}`;
+    }
+    core_1.ux.action.stop(status);
+    return app;
+}
+async function addAddons(heroku, app, addons) {
+    for (const addon of addons) {
+        const body = {
+            plan: addon.plan,
+            attachment: addon.as ? { name: addon.as } : undefined,
+        };
+        core_1.ux.action.start(`Adding ${color_1.default.green(addon.plan)}`);
+        await heroku.post(`/apps/${app.name}/addons`, { body });
+        core_1.ux.action.stop();
+    }
+}
+async function addConfigVars(heroku, app, configVars) {
+    if (Object.keys(configVars).length > 0) {
+        core_1.ux.action.start('Setting config vars');
+        await heroku.patch(`/apps/${app.name}/config-vars`, {
+            body: configVars,
+        });
+        core_1.ux.action.stop();
+    }
+}
+function addonsFromPlans(plans) {
+    return plans.map(plan => ({
+        plan: plan.trim(),
+    }));
+}
+async function configureGitRemote(context, app) {
+    const remoteUrl = git.httpGitUrl(app.name || '');
+    if (!context.flags['no-remote'] && git.inGitRepo()) {
+        await git.createRemote(context.flags.remote || 'heroku', remoteUrl);
+    }
+    return remoteUrl;
+}
+function printAppSummary(context, app, remoteUrl) {
+    if (context.flags.json) {
+        core_1.ux.styledJSON(app);
+    }
+    else {
+        core_1.ux.log(`${color_1.default.cyan(app.web_url || '')} | ${color_1.default.green(remoteUrl)}`);
+    }
+}
+async function runFromFlags(context, heroku, config) {
+    const { flags, args } = context;
+    if (flags['internal-routing'] && !flags.space) {
+        throw new Error('Space name required.\nInternal Web Apps are only available for Private Spaces.\nUSAGE: heroku apps:create --space my-space --internal-routing');
+    }
+    const name = flags.app || args.app || process.env.HEROKU_APP;
+    async function addBuildpack(app, buildpack) {
+        core_1.ux.action.start(`Setting buildpack to ${color_1.default.cyan(buildpack)}`);
+        await heroku.put(`/apps/${app.name}/buildpack-installations`, {
+            headers: { Range: '' },
+            body: { updates: [{ buildpack: buildpack }] },
+        });
+        core_1.ux.action.stop();
+    }
+    core_1.ux.action.start(createText(name, flags.space));
+    const app = await createApp(context, heroku, name, flags.stack);
+    core_1.ux.action.stop();
+    if (flags.addons) {
+        const plans = flags.addons.split(',');
+        const addons = addonsFromPlans(plans);
+        await addAddons(heroku, app, addons);
+    }
+    if (flags.buildpack) {
+        await addBuildpack(app, flags.buildpack);
+    }
+    const remoteUrl = await configureGitRemote(context, app);
+    await config.runHook('recache', { type: 'app', app: app.name });
+    printAppSummary(context, app, remoteUrl);
+}
+async function readManifest() {
+    const buffer = await (0, fs_extra_1.readFile)('heroku.yml');
+    return yaml.load(buffer.toString(), { filename: 'heroku.yml' });
+}
+async function runFromManifest(context, heroku) {
+    const { flags, args } = context;
+    const name = flags.app || args.app || process.env.HEROKU_APP;
+    core_1.ux.action.start('Reading heroku.yml manifest');
+    const manifest = await readManifest();
+    core_1.ux.action.stop();
+    core_1.ux.action.start(createText(name, flags.space));
+    const app = await createApp(context, heroku, name, 'container');
+    core_1.ux.action.stop();
+    // _.get used here to avoid type guards when working with `unknown`
+    const setup = (0, lodash_1.get)(manifest, 'setup', {});
+    const addons = setup.addons || [];
+    const configVars = setup.config || {};
+    await addAddons(heroku, app, addons);
+    await addConfigVars(heroku, app, configVars);
+    const remoteUrl = await configureGitRemote(context, app);
+    printAppSummary(context, app, remoteUrl);
+}
+class Create extends command_1.Command {
+    async run() {
+        const context = await this.parse(Create);
+        const { flags } = context;
+        if (this.config.channel === 'beta' && flags.manifest) {
+            return runFromManifest(context, this.heroku);
+        }
+        await runFromFlags(context, this.heroku, this.config);
+    }
+}
+exports.default = Create;
+Create.description = 'creates a new app';
+Create.hiddenAliases = ['create'];
+Create.examples = [
+    `$ heroku apps:create
+Creating app... done, stack is heroku-22
+https://floating-dragon-42.heroku.com/ | https://git.heroku.com/floating-dragon-42.git
+
+# or just
+$ heroku create
+
+# use a heroku.yml manifest file
+$ heroku apps:create --manifest
+
+# specify a buildpack
+$ heroku apps:create --buildpack https://github.com/some/buildpack.git
+
+# specify a name
+$ heroku apps:create example
+
+# create a staging app
+$ heroku apps:create example-staging --remote staging
+
+# create an app in the eu region
+$ heroku apps:create --region eu`,
+];
+Create.args = {
+    app: core_1.Args.string({ description: 'name of app to create', required: false }),
+};
+Create.flags = {
+    // `app` set to `flags.string` instead of `flags.app` to maintain original v5 functionality and avoid a default value from the git remote set when used without an app
+    app: command_1.flags.string({ hidden: true }),
+    addons: command_1.flags.string({ description: 'comma-delimited list of addons to install' }),
+    buildpack: command_1.flags.string({
+        char: 'b',
+        description: 'buildpack url to use for this app',
+        completion: completions_1.BuildpackCompletion,
+    }),
+    manifest: command_1.flags.boolean({ char: 'm', description: 'use heroku.yml settings for this app', hidden: true }),
+    'no-remote': command_1.flags.boolean({ char: 'n', description: 'do not create a git remote' }),
+    remote: command_1.flags.remote({ description: 'the git remote to create, default "heroku"', default: 'heroku' }),
+    stack: command_1.flags.string({ char: 's', description: 'the stack to create the app on', completion: completions_1.StackCompletion }),
+    space: command_1.flags.string({ description: 'the private space to create the app in', completion: completions_1.SpaceCompletion }),
+    region: command_1.flags.string({ description: 'specify region for the app to run in', completion: completions_1.RegionCompletion }),
+    'internal-routing': command_1.flags.boolean({
+        hidden: true,
+        description: 'private space-only. create as an Internal Web App that is only routable in the local network.',
+    }),
+    features: command_1.flags.string({ hidden: true }),
+    kernel: command_1.flags.string({ hidden: true }),
+    locked: command_1.flags.boolean({ hidden: true }),
+    json: command_1.flags.boolean({ description: 'output in json format' }),
+    team: command_1.flags.team(),
+};

package/lib/commands/apps/destroy.d.ts

@@ -0,0 +1,15 @@
+import { Command } from '@heroku-cli/command';
+export default class Destroy extends Command {
+    static description: string;
+    static help: string;
+    static hiddenAliases: 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>;
+        confirm: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+    };
+    static args: {
+        app: import("@oclif/core/lib/interfaces/parser").Arg<string | undefined, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/apps/destroy.js

@@ -0,0 +1,47 @@
+"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 lodash_1 = require("lodash");
+const confirmCommand_1 = require("../../lib/confirmCommand");
+const git = require("../../lib/ci/git");
+class Destroy extends command_1.Command {
+    async run() {
+        const { flags, args } = await this.parse(Destroy);
+        const app = args.app || flags.app;
+        if (!app)
+            throw new Error('No app specified.\nUSAGE: heroku apps:destroy APPNAME');
+        // this appears to report errors if app not found
+        await this.heroku.get(`/apps/${app}`);
+        await (0, confirmCommand_1.default)(app, flags.confirm, `WARNING: This will delete ${color_1.default.app(app)} including all add-ons.`);
+        core_1.ux.action.start(`Destroying ${color_1.default.app(app)} (including all add-ons)`);
+        await this.heroku.delete(`/apps/${app}`);
+        if (git.inGitRepo()) {
+            // delete git remotes pointing to this app
+            await git.listRemotes()
+                .then(remotes => {
+                const transformed = remotes
+                    .filter(r => git.gitUrl(app) === r[1] || git.sshGitUrl(app) === r[1])
+                    .map(r => r[0]);
+                const uniqueRemotes = (0, lodash_1.uniq)(transformed);
+                uniqueRemotes.forEach(element => {
+                    git.rmRemote(element);
+                });
+            });
+        }
+        core_1.ux.action.stop();
+    }
+}
+exports.default = Destroy;
+Destroy.description = 'permanently destroy an app';
+Destroy.help = 'This will also destroy all add-ons on the app.';
+Destroy.hiddenAliases = ['destroy', 'apps:delete'];
+Destroy.flags = {
+    app: command_1.flags.app(),
+    remote: command_1.flags.remote(),
+    confirm: command_1.flags.string({ char: 'c' }),
+};
+Destroy.args = {
+    app: core_1.Args.string({ hidden: true }),
+};

package/lib/commands/apps/errors.d.ts

@@ -0,0 +1,13 @@
+import { Command } from '@heroku-cli/command';
+export default class Errors 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>;
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        hours: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        router: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        dyno: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}