heroku 9.0.0-alpha.0 → 9.0.0-alpha.2

package/lib/commands/container/pull.d.ts

@@ -0,0 +1,14 @@
+import { Command } from '@heroku-cli/command';
+export default class Pull extends Command {
+    static topic: string;
+    static description: string;
+    static usage: string;
+    static example: 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>;
+        verbose: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/container/pull.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const DockerHelper = require("../../lib/container/docker_helper");
+const debug_1 = require("../../lib/container/debug");
+const color_1 = require("@heroku-cli/color");
+class Pull extends command_1.Command {
+    async run() {
+        const { argv, flags } = await this.parse(Pull);
+        const { verbose, app } = flags;
+        if (argv.length === 0) {
+            this.error(`Error: Requires one or more process types\n${Pull.example}`);
+        }
+        const herokuHost = process.env.HEROKU_HOST || 'heroku.com';
+        const registry = `registry.${herokuHost}`;
+        if (verbose) {
+            debug_1.debug.enabled = true;
+        }
+        for (const process of argv) {
+            const tag = `${registry}/${app}/${process}`;
+            core_1.ux.styledHeader(`Pulling ${process} as ${tag}`);
+            await DockerHelper.pullImage(tag);
+        }
+    }
+}
+exports.default = Pull;
+Pull.topic = 'container';
+Pull.description = 'pulls an image from an app\'s process type';
+Pull.usage = 'container:pull -a APP [-v] PROCESS_TYPE...';
+Pull.example = `
+  ${color_1.default.cmd('$ heroku container:pull web')}        # Pulls the web image from the app
+  ${color_1.default.cmd('$ heroku container:pull web worker')} # Pulls both the web and worker images from the app
+  ${color_1.default.cmd('$ heroku container:pull web:latest')} # Pulls the latest tag from the web image`;
+Pull.strict = false;
+Pull.flags = {
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+    verbose: command_1.flags.boolean({ char: 'v' }),
+};

package/lib/commands/container/push.d.ts

@@ -0,0 +1,16 @@
+import { Command } from '@heroku-cli/command';
+export default class Push extends Command {
+    static topic: string;
+    static description: string;
+    static strict: boolean;
+    static flags: {
+        app: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        verbose: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        recursive: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        arg: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        'context-path': 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 examples: string[];
+    run(): Promise<void>;
+}

package/lib/commands/container/push.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const DockerHelper = require("../../lib/container/docker_helper");
+const debug_1 = require("../../lib/container/debug");
+async function selectJobs(jobs, processTypes, recursive) {
+    let filteredJobs = {};
+    let selectedJobs = [];
+    if (Object.keys(jobs).length === 0) {
+        return selectedJobs;
+    }
+    if (recursive) {
+        if (processTypes.length > 0) {
+            filteredJobs = DockerHelper.filterByProcessType(jobs, processTypes);
+        }
+        selectedJobs = await DockerHelper.chooseJobs(filteredJobs);
+    }
+    else if (jobs.standard) {
+        jobs.standard.forEach(pj => {
+            pj.resource = pj.resource.replace(/standard$/, processTypes[0]);
+        });
+        selectedJobs = jobs.standard || [];
+    }
+    return selectedJobs;
+}
+class Push extends command_1.Command {
+    async run() {
+        const { argv: processTypes, flags } = await this.parse(Push);
+        const { verbose, app, recursive, arg, 'context-path': contextPath } = flags;
+        if (verbose) {
+            debug_1.debug.enabled = true;
+        }
+        if (processTypes.length === 0 && !recursive) {
+            core_1.ux.error('Requires either --recursive or one or more process types', { exit: 1 });
+        }
+        if (processTypes.length > 1 && !recursive) {
+            core_1.ux.error('Requires exactly one target process type, or --recursive option', { exit: 1 });
+        }
+        await this.heroku.get(`/apps/${app}`);
+        const herokuHost = process.env.HEROKU_HOST || 'heroku.com';
+        const registry = `registry.${herokuHost}`;
+        const dockerfiles = DockerHelper.getDockerfiles(process.cwd(), recursive);
+        const possibleJobs = DockerHelper.getJobs(`${registry}/${app}`, dockerfiles);
+        const jobs = await selectJobs(possibleJobs, processTypes, recursive);
+        if (jobs.length === 0) {
+            core_1.ux.error('No images to push', { exit: 1 });
+        }
+        const buildArgs = (arg === undefined) ? [] : arg.split(',');
+        try {
+            for (const job of jobs) {
+                if (job.name === 'standard') {
+                    core_1.ux.styledHeader(`Building ${processTypes} (${job.dockerfile})`);
+                }
+                else {
+                    core_1.ux.styledHeader(`Building ${job.name} (${job.dockerfile})`);
+                }
+                await DockerHelper.buildImage(job.dockerfile, job.resource, buildArgs, contextPath);
+            }
+        }
+        catch (error) {
+            core_1.ux.error(`docker build exited with ${error}`, { exit: 1 });
+        }
+        try {
+            for (const job of jobs) {
+                if (job.name === 'standard') {
+                    core_1.ux.styledHeader(`Pushing ${processTypes} (${job.dockerfile})`);
+                }
+                else {
+                    core_1.ux.styledHeader(`Pushing ${job.name} (${job.dockerfile})`);
+                }
+                await DockerHelper.pushImage(job.resource);
+            }
+            const plural = jobs.length !== 1;
+            core_1.ux.log(`Your image${plural ? 's have' : ' has'} been successfully pushed. You can now release ${plural ? 'them' : 'it'} with the 'container:release' command.`);
+        }
+        catch (error) {
+            core_1.ux.error(`docker push exited with ${error}`, { exit: 1 });
+        }
+    }
+}
+exports.default = Push;
+Push.topic = 'container';
+Push.description = 'builds, then pushes Docker images to deploy your Heroku app';
+Push.strict = false;
+Push.flags = {
+    app: command_1.flags.app({ required: true }),
+    verbose: command_1.flags.boolean({ char: 'v' }),
+    recursive: command_1.flags.boolean({ char: 'R', description: 'pushes Dockerfile.<process> found in current and subdirectories' }),
+    arg: command_1.flags.string({ description: 'set build-time variables' }),
+    'context-path': command_1.flags.string({ description: 'path to use as build context (defaults to Dockerfile dir)' }),
+    remote: command_1.flags.remote({ char: 'r' }),
+};
+Push.examples = [
+    '$ heroku container:push web                          # Pushes Dockerfile to web process type',
+    '$ heroku container:push worker                       # Pushes Dockerfile to worker process type',
+    '$ heroku container:push web worker --recursive       # Pushes Dockerfile.web and Dockerfile.worker',
+    '$ heroku container:push --recursive                  # Pushes Dockerfile.*',
+    '$ heroku container:push web --arg ENV=live,HTTPS=on  # Build-time variables',
+    '$ heroku container:push --recursive --context-path . # Pushes Dockerfile.* using current dir as build context',
+];

package/lib/commands/container/release.d.ts

@@ -0,0 +1,14 @@
+import { Command } from '@heroku-cli/command';
+export default class ContainerRelease extends Command {
+    static topic: string;
+    static description: string;
+    static usage: string;
+    static example: 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>;
+        verbose: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/container/release.js

@@ -0,0 +1,89 @@
+"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 debug_1 = require("../../lib/container/debug");
+const streamer_1 = require("../../lib/container/streamer");
+class ContainerRelease extends command_1.Command {
+    async run() {
+        const { flags, argv } = await this.parse(ContainerRelease);
+        const { app, verbose } = flags;
+        if (argv.length === 0) {
+            this.error(`Error: Requires one or more process types\n ${ContainerRelease.example}`);
+        }
+        if (verbose) {
+            debug_1.debug.enabled = true;
+        }
+        await this.heroku.get(`/apps/${app}`);
+        const herokuHost = process.env.HEROKU_HOST || 'heroku.com';
+        const updateData = [];
+        for (const process of argv) {
+            const image = `${app}/${process}`;
+            const tag = 'latest';
+            const { body: imageResp } = await this.heroku.get(`/v2/${image}/manifests/${tag}`, {
+                hostname: `registry.${herokuHost}`,
+                headers: {
+                    Accept: 'application/vnd.docker.distribution.manifest.v2+json',
+                    Authorization: `Basic ${Buffer.from(`:${this.heroku.auth}`).toString('base64')}`,
+                }
+            });
+            let imageID;
+            let v1Comp;
+            switch (imageResp.schemaVersion) {
+                case 1:
+                    v1Comp = JSON.parse(imageResp.history[0].v1Compatibility);
+                    imageID = v1Comp.id;
+                    break;
+                case 2:
+                    imageID = imageResp.config.digest;
+                    break;
+            }
+            updateData.push({
+                type: process, docker_image: imageID,
+            });
+        }
+        core_1.ux.action.start(`Releasing images ${argv.join(',')} to ${app}`);
+        await this.heroku.patch(`/apps/${app}/formation`, {
+            body: { updates: updateData }, headers: {
+                Accept: 'application/vnd.heroku+json; version=3.docker-releases',
+            },
+        });
+        core_1.ux.action.stop();
+        const { body: oldReleases } = await this.heroku.get(`/apps/${app}/releases`, {
+            partial: true, headers: { Range: 'version ..; max=2, order=desc' },
+        });
+        const oldRelease = oldReleases[0];
+        const { body: updatedReleases } = await this.heroku.get(`/apps/${app}/releases`, {
+            partial: true, headers: { Range: 'version ..; max=1, order=desc' },
+        });
+        const release = updatedReleases[0];
+        if ((!oldRelease && !release) || (oldRelease && (oldRelease.id === release.id))) {
+            return;
+        }
+        if (release.status === 'failed') {
+            core_1.ux.error('Error: release command failed', { exit: 1 });
+        }
+        else if ((release.status === 'pending') && release.output_stream_url) {
+            core_1.ux.log('Running release command...');
+            await (0, streamer_1.streamer)(release.output_stream_url, process.stdout);
+            const { body: finishedRelease } = await this.heroku.request(`/apps/${app}/releases/${release.id}`);
+            if (finishedRelease.status === 'failed') {
+                core_1.ux.error('Error: release command failed', { exit: 1 });
+            }
+        }
+    }
+}
+exports.default = ContainerRelease;
+ContainerRelease.topic = 'container';
+ContainerRelease.description = 'Releases previously pushed Docker images to your Heroku app';
+ContainerRelease.usage = 'container:release';
+ContainerRelease.example = `
+  ${color_1.default.cmd('heroku container:release web')}        # Releases the previously pushed web process type
+  ${color_1.default.cmd('heroku container:release web worker')} # Releases the previously pushed web and worker process types`;
+ContainerRelease.strict = false;
+ContainerRelease.flags = {
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+    verbose: command_1.flags.boolean({ char: 'v' }),
+};

package/lib/commands/container/rm.d.ts

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

package/lib/commands/container/rm.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const color_1 = require("@heroku-cli/color");
+class Rm extends command_1.Command {
+    async run() {
+        const { argv, flags } = await this.parse(Rm);
+        const { app } = flags;
+        if (argv.length === 0) {
+            this.error(`Error: Requires one or more process types\n${Rm.example}`);
+        }
+        for (const process of argv) {
+            core_1.ux.action.start(`Removing container ${process} for ${color_1.default.app(app)}`);
+            await this.heroku.patch(`/apps/${app}/formation/${process}`, {
+                headers: {
+                    Accept: 'application/vnd.heroku+json; version=3.docker-releases',
+                },
+                body: { docker_image: null },
+            });
+            core_1.ux.action.stop();
+        }
+    }
+}
+exports.default = Rm;
+Rm.topic = 'container';
+Rm.description = 'remove the process type from your app';
+Rm.usage = 'container:rm -a APP [-v] PROCESS_TYPE...';
+Rm.example = `
+  ${color_1.default.cmd('heroku container:rm web')}        # Destroys the web container
+  ${color_1.default.cmd('heroku container:rm web worker')} # Destroys the web and worker containers`;
+Rm.strict = false;
+Rm.flags = {
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+};

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

@@ -0,0 +1,15 @@
+import { Command } from '@heroku-cli/command';
+export default class Run extends Command {
+    static topic: string;
+    static description: string;
+    static usage: string;
+    static example: 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>;
+        port: import("@oclif/core/lib/interfaces").OptionFlag<number, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        verbose: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/container/run.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const DockerHelper = require("../../lib/container/docker_helper");
+const debug_1 = require("../../lib/container/debug");
+const color_1 = require("@heroku-cli/color");
+class Run extends command_1.Command {
+    async run() {
+        const { argv, flags } = await this.parse(Run);
+        const { verbose, app, port } = flags;
+        if (argv.length === 0) {
+            this.error(`Error: Requires one process type\n${Run.example}`);
+        }
+        if (verbose) {
+            debug_1.debug.enabled = true;
+        }
+        const processType = argv.shift();
+        const command = argv.join(' ');
+        const herokuHost = process.env.HEROKU_HOST || 'heroku.com';
+        const registry = `registry.${herokuHost}`;
+        const dockerfiles = DockerHelper.getDockerfiles(process.cwd(), false);
+        const possibleJobs = DockerHelper.getJobs(`${registry}/${app}`, dockerfiles);
+        let jobs = [];
+        if (possibleJobs.standard) {
+            possibleJobs.standard.forEach((pj) => {
+                pj.resource = pj.resource.replace(/standard$/, processType);
+            });
+            jobs = possibleJobs.standard || [];
+        }
+        if (jobs.length === 0) {
+            core_1.ux.error('No images to run');
+        }
+        const job = jobs[0];
+        if (command.length === 0) {
+            core_1.ux.styledHeader(`Running ${job.resource}`);
+        }
+        else {
+            core_1.ux.styledHeader(`Running '${command}' on ${job.resource}`);
+        }
+        try {
+            await DockerHelper.runImage(job.resource, command, port);
+        }
+        catch (error) {
+            core_1.ux.error(`docker run exited with ${error}`);
+        }
+    }
+}
+exports.default = Run;
+Run.topic = 'container';
+Run.description = 'builds, then runs the docker image locally';
+Run.usage = 'container:run -a APP [-v] PROCESS_TYPE...';
+Run.example = `
+  ${color_1.default.cmd('$ heroku container:pull web')}        # Pulls the web image from the app
+  ${color_1.default.cmd('$ heroku container:pull web worker')} # Pulls both the web and worker images from the app
+  ${color_1.default.cmd('$ heroku container:pull web:latest')} # Pulls the latest tag from the web image`;
+Run.strict = false;
+Run.flags = {
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+    port: command_1.flags.integer({ char: 'p', description: 'port the app will run on', default: 5000 }),
+    verbose: command_1.flags.boolean({ char: 'v' }),
+};

package/lib/commands/dashboard.d.ts

@@ -0,0 +1,7 @@
+import { Command } from '@heroku-cli/command';
+export default class Dashboard extends Command {
+    static topic: string;
+    static description: string;
+    static hidden: boolean;
+    run(): Promise<void>;
+}

package/lib/commands/dashboard.js

@@ -0,0 +1,164 @@
+"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 img = require("term-img");
+const path = require("path");
+const child_process_1 = require("child_process");
+const sparkline = require('sparkline');
+const time_1 = require("../lib/time");
+const process = require("process");
+const empty = (o) => Object.keys(o).length === 0;
+function displayFormation(formation) {
+    formation = (0, lodash_1.groupBy)(formation, 'size');
+    formation = (0, lodash_1.map)(formation, (p, size) => `${bold((0, lodash_1.sumBy)(p, 'quantity').toString())} | ${size}`);
+    core_1.ux.log(`  ${label('Dynos:')} ${formation.join(', ')}`);
+}
+function displayErrors(metrics) {
+    let errors = [];
+    if (metrics.routerErrors) {
+        errors = errors.concat(Object.entries(metrics.routerErrors.data)
+            .map(e => color_1.default.red(`${(0, lodash_1.sum)(e[1])} ${e[0]}`)));
+    }
+    if (metrics.dynoErrors) {
+        metrics.dynoErrors.filter(d => d)
+            .forEach(dynoErrors => {
+            errors = errors.concat(Object.entries((dynoErrors === null || dynoErrors === void 0 ? void 0 : dynoErrors.data) || {})
+                .map(e => color_1.default.red(`${(0, lodash_1.sum)(e[1])} ${e[0]}`)));
+        });
+    }
+    if (errors.length > 0)
+        core_1.ux.log(`  ${label('Errors:')} ${errors.join(dim(', '))} (see details with ${color_1.default.cyan.bold('heroku apps:errors')})`);
+}
+function displayMetrics(metrics) {
+    function rpmSparkline() {
+        var _a;
+        if (['win32', 'windows'].includes(process.platform))
+            return '';
+        const points = [];
+        Object.values(((_a = metrics.routerStatus) === null || _a === void 0 ? void 0 : _a.data) || {})
+            .forEach(cur => {
+            for (const [i, element] of cur.entries()) {
+                const j = Math.floor(i / 3);
+                points[j] = (points[j] || 0) + element;
+            }
+        });
+        points.pop();
+        return dim(sparkline(points)) + ' last 24 hours rpm';
+    }
+    let ms = '';
+    let rpm = '';
+    if (metrics.routerLatency && !empty(metrics.routerLatency.data)) {
+        const latency = metrics.routerLatency.data['latency.ms.p50'];
+        if (!empty(latency))
+            ms = `${(0, lodash_1.round)((0, lodash_1.mean)(latency))} ms `;
+    }
+    if (metrics.routerStatus && !empty(metrics.routerStatus.data)) {
+        rpm = `${(0, lodash_1.round)((0, lodash_1.sum)((0, lodash_1.flatten)(Object.values(metrics.routerStatus.data))) / 24 / 60)} rpm ${rpmSparkline()}`;
+    }
+    if (rpm || ms)
+        core_1.ux.log(`  ${label('Metrics:')} ${ms}${rpm}`);
+}
+function displayNotifications(notifications) {
+    if (!notifications)
+        return;
+    notifications = notifications.filter(n => !n.read);
+    if (notifications.length > 0) {
+        core_1.ux.log(`\nYou have ${color_1.default.yellow(notifications.length.toString())} unread notifications. Read them with ${color_1.default.cyan.bold('heroku notifications')}`);
+    }
+}
+const dim = (s) => color_1.default.dim(s);
+const bold = (s) => color_1.default.bold(s);
+const label = (s) => color_1.default.blue(s);
+const fetchMetrics = async (apps, heroku) => {
+    const NOW = new Date().toISOString();
+    const YESTERDAY = new Date(Date.now() - (24 * 60 * 60 * 1000)).toISOString();
+    const date = `start_time=${YESTERDAY}&end_time=${NOW}&step=1h`;
+    const metricsData = await Promise.all(apps.map(app => {
+        const types = app.formation.map((p) => p.type);
+        const dynoErrorsPromise = Promise.all(types.map((type) => heroku.get(`/apps/${app.app.name}/formation/${type}/metrics/errors?${date}`, { hostname: 'api.metrics.herokai.com' }).catch(() => { })));
+        return Promise.all([
+            dynoErrorsPromise,
+            heroku.get(`/apps/${app.app.name}/router-metrics/latency?${date}&process_type=${types[0]}`, { hostname: 'api.metrics.herokai.com' }).catch(() => { }),
+            heroku.get(`/apps/${app.app.name}/router-metrics/errors?${date}&process_type=${types[0]}`, { hostname: 'api.metrics.herokai.com' }).catch(() => { }),
+            heroku.get(`/apps/${app.app.name}/router-metrics/status?${date}&process_type=${types[0]}`, { hostname: 'api.metrics.herokai.com' }).catch(() => { }),
+        ]);
+    }));
+    return metricsData.map(([dynoErrors, routerLatency, routerErrors, routerStatus]) => ({
+        dynoErrors, routerLatency: routerLatency === null || routerLatency === void 0 ? void 0 : routerLatency.body, routerErrors: routerErrors === null || routerErrors === void 0 ? void 0 : routerErrors.body, routerStatus: routerStatus === null || routerStatus === void 0 ? void 0 : routerStatus.body,
+    }));
+};
+function displayApps(apps, appsMetrics) {
+    var _a;
+    const getOwner = (owner) => { var _a; return ((_a = owner === null || owner === void 0 ? void 0 : owner.email) === null || _a === void 0 ? void 0 : _a.endsWith('@herokumanager.com')) ? owner.email.split('@')[0] : owner === null || owner === void 0 ? void 0 : owner.email; };
+    const zipped = (0, lodash_1.zip)(apps, appsMetrics);
+    for (const a of zipped) {
+        const app = a[0];
+        const metrics = a[1];
+        core_1.ux.log(color_1.default.magenta(app.app.name || ''));
+        core_1.ux.log(`  ${label('Owner:')} ${getOwner(app.app.owner)}`);
+        if (app.pipeline) {
+            core_1.ux.log(`  ${label('Pipeline:')} ${(_a = app.pipeline.pipeline) === null || _a === void 0 ? void 0 : _a.name}`);
+        }
+        displayFormation(app.formation);
+        core_1.ux.log(`  ${label('Last release:')} ${(0, time_1.ago)(new Date(app.app.released_at || ''))}`);
+        displayMetrics(metrics);
+        displayErrors(metrics);
+        core_1.ux.log();
+    }
+}
+class Dashboard extends command_1.Command {
+    async run() {
+        if (!this.heroku.auth && process.env.IS_HEROKU_TEST_ENV !== 'true') {
+            (0, child_process_1.execSync)('heroku help', { stdio: 'inherit' });
+            return;
+        }
+        const favoriteApps = async () => {
+            const { body: apps } = await this.heroku.get('/favorites?type=app', {
+                hostname: 'particleboard.heroku.com',
+            });
+            return apps.map(app => app.resource_name);
+        };
+        try {
+            img(path.join(__dirname, '..', '..', 'assets', 'heroku.png'), { fallback: () => { } });
+        }
+        catch (_a) { }
+        core_1.ux.action.start('Loading');
+        const apps = await favoriteApps();
+        const [{ body: teams }, notificationsResponse, appsWithMoreInfo] = await Promise.all([
+            this.heroku.get('/teams'),
+            this.heroku.get('/user/notifications', { hostname: 'telex.heroku.com' })
+                .catch(() => null),
+            Promise.all(apps.map(async (appID) => {
+                const [{ body: app }, { body: formation }, pipelineResponse] = await Promise.all([
+                    this.heroku.get(`/apps/${appID}`),
+                    this.heroku.get(`/apps/${appID}/formation`),
+                    this.heroku.get(`/apps/${appID}/pipeline-couplings`)
+                        .catch(() => null),
+                ]);
+                return {
+                    app, formation, pipeline: pipelineResponse === null || pipelineResponse === void 0 ? void 0 : pipelineResponse.body,
+                };
+            })),
+        ]);
+        const metrics = await fetchMetrics(appsWithMoreInfo, this.heroku);
+        core_1.ux.action.stop();
+        if (apps.length > 0)
+            displayApps(appsWithMoreInfo, metrics);
+        else
+            core_1.ux.warn(`Add apps to this dashboard by favoriting them with ${color_1.default.cyan.bold('heroku apps:favorites:add')}`);
+        core_1.ux.log(`See all add-ons with ${color_1.default.cyan.bold('heroku addons')}`);
+        const sampleTeam = (0, lodash_1.sortBy)(teams.filter(o => o.role !== 'collaborator'), o => new Date(o.created_at || ''))[0];
+        if (sampleTeam)
+            core_1.ux.log(`See all apps in ${color_1.default.yellow.dim(sampleTeam.name || '')} with ${color_1.default.cyan.bold('heroku apps --team ' + sampleTeam.name)}`);
+        core_1.ux.log(`See all apps with ${color_1.default.cyan.bold('heroku apps --all')}`);
+        displayNotifications(notificationsResponse === null || notificationsResponse === void 0 ? void 0 : notificationsResponse.body);
+        core_1.ux.log(`\nSee other CLI commands with ${color_1.default.cyan.bold('heroku help')}\n`);
+    }
+}
+exports.default = Dashboard;
+Dashboard.topic = 'dashboard';
+Dashboard.description = 'display information about favorite apps';
+Dashboard.hidden = true;

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

@@ -6,11 +6,11 @@ export default class DomainsIndex extends Command {
     static flags: {
         extended: import("@oclif/core/lib/interfaces").Flag<boolean>;
         'no-header': import("@oclif/core/lib/interfaces").Flag<boolean>;
-        sort: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
         filter: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        sort: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        output: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
         columns: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
         csv: import("@oclif/core/lib/interfaces").Flag<boolean>;
-        output: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
         help: import("@oclif/core/lib/interfaces").BooleanFlag<void>;
         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>;
@@ -22,7 +22,7 @@ export default class DomainsIndex extends Command {
         };
         kind: {
             header: string;
-            get: (domain: Heroku.Domain) => "ALIAS or ANAME" | "CNAME" | undefined;
+            get: (domain: Heroku.Domain) => "CNAME" | "ALIAS or ANAME" | undefined;
         };
         cname: {
             header: string;

package/lib/commands/drains/add.d.ts

@@ -0,0 +1,12 @@
+import { Command } from '@heroku-cli/command';
+export default class Add 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>;
+    };
+    static args: {
+        url: import("@oclif/core/lib/interfaces/parser").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/drains/add.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const color_1 = require("@heroku-cli/color");
+const command_1 = require("@heroku-cli/command");
+class Add extends command_1.Command {
+    async run() {
+        const { flags, args } = await this.parse(Add);
+        const { body: drain } = await this.heroku.post(`/apps/${flags.app}/log-drains`, {
+            body: { url: args.url },
+        });
+        core_1.ux.log(`Successfully added drain ${color_1.default.cyan(drain.url || '')}`);
+    }
+}
+exports.default = Add;
+Add.description = 'adds a log drain to an app';
+Add.flags = {
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+};
+Add.args = {
+    url: core_1.Args.string({ required: true }),
+};