heroku 9.0.0-alpha.0 → 9.0.0-alpha.1

package/README.md

@@ -41,7 +41,7 @@ For other issues, [submit a support ticket](https://help.heroku.com/).
 * [`heroku autocomplete`](docs/autocomplete.md) - display autocomplete installation instructions
 * [`heroku buildpacks`](docs/buildpacks.md) - scripts used to compile apps
 * [`heroku certs`](docs/certs.md) - a topic for the ssl plugin
-* [`heroku ci`](docs/ci.md) - run an application test suite on Heroku
+* [`heroku ci`](docs/ci.md) - test runner for Heroku Pipelines
 * [`heroku clients`](docs/clients.md) - OAuth clients on the platform
 * [`heroku config`](docs/config.md) - environment variables of apps
 * [`heroku container`](docs/container.md) - Use containers to build and deploy Heroku apps
@@ -56,13 +56,16 @@ For other issues, [submit a support ticket](https://help.heroku.com/).
 * [`heroku logs`](docs/logs.md) - display recent log output
 * [`heroku maintenance`](docs/maintenance.md) - enable/disable access to app
 * [`heroku members`](docs/members.md) - manage organization members
+* [`heroku notifications`](docs/notifications.md) - display notifications
 * [`heroku orgs`](docs/orgs.md) - manage organizations
 * [`heroku pg`](docs/pg.md) - manage postgresql databases
 * [`heroku pipelines`](docs/pipelines.md) - manage pipelines
 * [`heroku plugins`](docs/plugins.md) - List installed plugins.
 * [`heroku ps`](docs/ps.md) - Client tools for Heroku Exec
+* [`heroku psql`](docs/psql.md) - open a psql shell to the database
 * [`heroku redis`](docs/redis.md) - manage heroku redis instances
 * [`heroku regions`](docs/regions.md) - list available regions for deployment
+* [`heroku releases`](docs/releases.md) - display the releases for an app
 * [`heroku reviewapps`](docs/reviewapps.md) - manage reviewapps in pipelines
 * [`heroku run`](docs/run.md) - run a one-off process inside a Heroku dyno
 * [`heroku sessions`](docs/sessions.md) - OAuth sessions

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 aliases: string[];
+    static examples: string[];
+    static args: {
+        apps: 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,194 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const js_yaml_1 = 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 (0, js_yaml_1.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.aliases = ['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 = {
+    apps: 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,14 @@
+import { Command } from '@heroku-cli/command';
+export default class Destroy extends Command {
+    static description: string;
+    static help: string;
+    static aliases: string[];
+    static flags: {
+        app: 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,46 @@
+"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 confirm_app_1 = require("../../lib/apps/confirm-app");
+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, confirm_app_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.aliases = ['destroy', 'apps:delete'];
+Destroy.flags = {
+    app: command_1.flags.app(),
+    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,12 @@
+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>;
+        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>;
+}

package/lib/commands/apps/errors.js

@@ -0,0 +1,119 @@
+"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 error_info_1 = require("../../lib/apps/error_info");
+const colorize = (level, s) => {
+    switch (level) {
+        case 'critical':
+            return color_1.default.red(s);
+        case 'warning':
+            return color_1.default.yellow(s);
+        case 'info':
+            return color_1.default.cyan(s);
+        default:
+            return s;
+    }
+};
+function buildErrorTable(errors, source) {
+    return Object.keys(errors).map(name => {
+        const count = errors[name];
+        const info = error_info_1.default.find(e => e.name === name);
+        if (info) {
+            return { name, count, source, level: info.level, title: info.title };
+        }
+        return { name, count, source, level: 'critical', title: 'unknown error' };
+    });
+}
+const sumErrors = (errors) => {
+    const summed = {};
+    Object.keys(errors.data).forEach(key => {
+        summed[key] = (0, lodash_1.sum)(errors.data[key]);
+    });
+    return summed;
+};
+class Errors extends command_1.Command {
+    async run() {
+        const { flags } = await this.parse(Errors);
+        const hours = Number.parseInt(flags.hours);
+        const NOW = new Date().toISOString();
+        const YESTERDAY = new Date(Date.now() - (hours * 60 * 60 * 1000)).toISOString();
+        const DATE_QUERY = `start_time=${YESTERDAY}&end_time=${NOW}&step=1h`;
+        async function getAllDynoErrors(types) {
+            const values = await Promise.all(types.map(dynoErrors));
+            const memo = {};
+            types.forEach((key, index) => {
+                memo[key] = values[index];
+            });
+            return memo;
+        }
+        const routerErrors = () => {
+            return this.heroku.get(`/apps/${flags.app}/router-metrics/errors?${DATE_QUERY}&process_type=web`, {
+                hostname: 'api.metrics.herokai.com',
+            }).then(({ body }) => sumErrors(body));
+        };
+        const dynoErrors = (type) => {
+            return this.heroku.get(`/apps/${flags.app}/formation/${type}/metrics/errors?${DATE_QUERY}`, {
+                hostname: 'api.metrics.herokai.com',
+            }).catch(error => {
+                const { http } = error;
+                // eslint-disable-next-line prefer-regex-literals
+                const match = new RegExp('^invalid process_type provided', 'i');
+                if (http && http.statusCode === 400 && http.body && http.body.message && match.test(http.body.message)) {
+                    return { body: { data: {} } };
+                }
+                throw error;
+            }).then(rsp => {
+                const { body } = rsp;
+                return sumErrors(body);
+            });
+        };
+        const { body: formation } = await this.heroku.get(`/apps/${flags.app}/formation`);
+        const types = formation.map((p) => p.type);
+        const showDyno = flags.dyno || !flags.router;
+        const showRouter = flags.router || !flags.dyno;
+        const noDynoEmpty = Promise.resolve({});
+        const noRouterEmpty = Promise.resolve({});
+        const [dyno, router] = await Promise.all([
+            showDyno ? getAllDynoErrors(types) : noDynoEmpty,
+            showRouter ? routerErrors() : noRouterEmpty,
+        ]);
+        const errors = {
+            dyno,
+            router,
+        };
+        if (flags.json) {
+            core_1.ux.styledJSON(errors);
+        }
+        else {
+            let t = buildErrorTable(errors.router, 'router');
+            for (const type of Object.keys(errors.dyno)) {
+                t = t.concat(buildErrorTable(dyno[type], type));
+            }
+            if (t.length === 0) {
+                core_1.ux.log(`No errors on ${color_1.default.app(flags.app)} in the last ${hours} hours`);
+            }
+            else {
+                core_1.ux.styledHeader(`Errors on ${color_1.default.app(flags.app)} in the last ${hours} hours`);
+                core_1.ux.table(t, {
+                    source: {},
+                    name: { get: ({ name, level }) => colorize(level, name) },
+                    level: { get: ({ level }) => colorize(level, level) },
+                    title: { header: 'Desc' },
+                    count: {},
+                });
+            }
+        }
+    }
+}
+exports.default = Errors;
+Errors.description = 'view app errors';
+Errors.flags = {
+    app: command_1.flags.app({ required: true }),
+    json: command_1.flags.boolean({ description: 'output in json format' }),
+    hours: command_1.flags.string({ description: 'number of hours to look back (default 24)', default: '24' }),
+    router: command_1.flags.boolean({ description: 'show only router errors' }),
+    dyno: command_1.flags.boolean({ description: 'show only dyno errors' }),
+};

package/lib/commands/apps/favorites/add.d.ts

@@ -0,0 +1,9 @@
+import { Command } from '@heroku-cli/command';
+export default class Add extends Command {
+    static description: string;
+    static topic: string;
+    static flags: {
+        app: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/apps/favorites/add.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const color_1 = require("@heroku-cli/color");
+const core_1 = require("@oclif/core");
+const command_1 = require("@heroku-cli/command");
+class Add extends command_1.Command {
+    async run() {
+        const { flags } = await this.parse(Add);
+        const { app } = flags;
+        core_1.ux.action.start(`Adding ${color_1.default.app(app)} to favorites`);
+        const { body: favorites } = await this.heroku.get('/favorites?type=app', { hostname: 'particleboard.heroku.com' });
+        if (favorites.find(f => f.resource_name === app)) {
+            throw new Error(`${color_1.default.app(app)} is already a favorite app.`);
+        }
+        try {
+            await this.heroku.post('/favorites', {
+                hostname: 'particleboard.heroku.com',
+                body: { type: 'app', resource_id: app },
+            });
+        }
+        catch (error) {
+            if (error.statusCode === 404) {
+                core_1.ux.error('App not found');
+            }
+            else {
+                core_1.ux.error(error.cause);
+            }
+        }
+        core_1.ux.action.stop();
+    }
+}
+exports.default = Add;
+Add.description = 'favorites an app';
+Add.topic = 'apps';
+Add.flags = {
+    app: command_1.flags.app({ required: true }),
+};

package/lib/commands/apps/favorites/index.d.ts

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

package/lib/commands/apps/favorites/index.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const command_1 = require("@heroku-cli/command");
+class Index extends command_1.Command {
+    async run() {
+        const { flags } = await this.parse(Index);
+        const { body: favorites } = await this.heroku.get('/favorites?type=app', { hostname: 'particleboard.heroku.com' });
+        if (flags.json) {
+            core_1.ux.styledJSON(favorites);
+        }
+        else {
+            core_1.ux.styledHeader('Favorited Apps');
+            for (const f of favorites) {
+                core_1.ux.log(f.resource_name);
+            }
+        }
+    }
+}
+exports.default = Index;
+Index.description = 'list favorited apps';
+Index.topic = 'apps';
+Index.flags = {
+    json: command_1.flags.boolean({ char: 'j', description: 'output in json format' }),
+};

package/lib/commands/apps/favorites/remove.d.ts

@@ -0,0 +1,9 @@
+import { Command } from '@heroku-cli/command';
+export default class Remove extends Command {
+    static description: string;
+    static topic: string;
+    static flags: {
+        app: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/apps/favorites/remove.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const color_1 = require("@heroku-cli/color");
+const core_1 = require("@oclif/core");
+const command_1 = require("@heroku-cli/command");
+class Remove extends command_1.Command {
+    async run() {
+        const { flags } = await this.parse(Remove);
+        const { app } = flags;
+        core_1.ux.action.start(`Removing ${color_1.default.app(app)} from favorites`);
+        const { body: favorites } = await this.heroku.get('/favorites?type=app', { hostname: 'particleboard.heroku.com' });
+        const favorite = favorites.find(f => f.resource_name === app);
+        if (!favorite) {
+            throw new Error(`${color_1.default.app(app)} is not already a favorite app.`);
+        }
+        await this.heroku.delete(`/favorites/${favorite.id}`, {
+            hostname: 'particleboard.heroku.com',
+        });
+        core_1.ux.action.stop();
+    }
+}
+exports.default = Remove;
+Remove.description = 'unfavorites an app';
+Remove.topic = 'apps';
+Remove.flags = {
+    app: command_1.flags.app({ required: true }),
+};

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

@@ -0,0 +1,16 @@
+import { Command } from '@heroku-cli/command';
+export default class AppsIndex extends Command {
+    static description: string;
+    static topic: string;
+    static aliases: string[];
+    static examples: string[];
+    static flags: {
+        all: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        space: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        personal: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        'internal-routing': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        team: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+    };
+    run(): Promise<void>;
+}