heroku 8.1.9 → 8.2.0-beta.0

package/lib/commands/config/edit.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringToConfig = void 0;
+const color_1 = require("@heroku-cli/color");
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const _ = require("lodash");
+const quote_1 = require("../../lib/config/quote");
+const util_1 = require("../../lib/config/util");
+const editor = new util_1.Editor();
+function configToString(config) {
+    return Object.keys(config)
+        .sort()
+        .map(key => {
+        return `${key}=${(0, quote_1.quote)(config[key])}`;
+    })
+        .join('\n');
+}
+function removeDeleted(newConfig, original) {
+    for (const k of Object.keys(original)) {
+        // The api accepts empty strings
+        // as valid env var values
+        // In JS an empty string is falsey
+        if (!newConfig[k] && newConfig[k] !== '')
+            newConfig[k] = null;
+    }
+}
+function stringToConfig(s) {
+    return s.split('\n').reduce((config, line) => {
+        const error = () => {
+            throw new Error(`Invalid line: ${line}`);
+        };
+        if (!line)
+            return config;
+        const i = line.indexOf('=');
+        if (i === -1)
+            error();
+        config[line.slice(0, i)] = (0, quote_1.parse)(line.slice(i + 1)) || '';
+        return config;
+    }, {});
+}
+exports.stringToConfig = stringToConfig;
+function allKeys(a, b) {
+    return _.uniq([...Object.keys(a), ...Object.keys(b)].sort());
+}
+function showDiff(from, to) {
+    for (const k of allKeys(from, to)) {
+        if (from[k] === to[k])
+            continue;
+        if (k in from) {
+            core_1.ux.log(color_1.color.red(`- ${k}=${(0, quote_1.quote)(from[k])}`));
+        }
+        if (k in to) {
+            core_1.ux.log(color_1.color.green(`+ ${k}=${(0, quote_1.quote)(to[k])}`));
+        }
+    }
+}
+class ConfigEdit extends command_1.Command {
+    async run() {
+        const { flags: { app }, args: { key } } = await this.parse(ConfigEdit);
+        this.app = app;
+        core_1.ux.action.start('Fetching config');
+        const original = await this.fetchLatestConfig();
+        core_1.ux.action.stop();
+        let newConfig = Object.assign({}, original);
+        const prefix = `heroku-${app}-config-`;
+        if (key) {
+            newConfig[key] = await editor.edit(original[key], { prefix });
+            if (!original[key].endsWith('\n') && newConfig[key].endsWith('\n'))
+                newConfig[key] = newConfig[key].slice(0, -1);
+        }
+        else {
+            const s = await editor.edit(configToString(original), { prefix, postfix: '.sh' });
+            newConfig = stringToConfig(s);
+        }
+        if (!await this.diffPrompt(original, newConfig))
+            return;
+        core_1.ux.action.start('Verifying new config');
+        await this.verifyUnchanged(original);
+        core_1.ux.action.start('Updating config');
+        removeDeleted(newConfig, original);
+        await this.updateConfig(newConfig);
+        core_1.ux.action.stop();
+    }
+    async fetchLatestConfig() {
+        const { body: original } = await this.heroku.get(`/apps/${this.app}/config-vars`);
+        return original;
+    }
+    async diffPrompt(original, newConfig) {
+        if (_.isEqual(original, newConfig)) {
+            this.warn('no changes to config');
+            return false;
+        }
+        core_1.ux.log();
+        core_1.ux.log('Config Diff:');
+        showDiff(original, newConfig);
+        core_1.ux.log();
+        return core_1.ux.confirm(`Update config on ${color_1.color.app(this.app)} with these values?`);
+    }
+    async verifyUnchanged(original) {
+        const latest = await this.fetchLatestConfig();
+        if (!_.isEqual(original, latest)) {
+            throw new Error('Config changed on server. Refusing to update.');
+        }
+    }
+    async updateConfig(newConfig) {
+        await this.heroku.patch(`/apps/${this.app}/config-vars`, {
+            body: newConfig,
+        });
+    }
+}
+exports.default = ConfigEdit;
+ConfigEdit.description = `interactively edit config vars
+This command opens the app config in a text editor set by $VISUAL or $EDITOR.
+Any variables added/removed/changed will be updated on the app after saving and closing the file.`;
+ConfigEdit.examples = [
+    `# edit with vim
+$ EDITOR="vim" heroku config:edit`,
+    `# edit with emacs
+$ EDITOR="emacs" heroku config:edit`,
+    `# edit with pico
+$ EDITOR="pico" heroku config:edit`,
+    `# edit with atom editor
+$ VISUAL="atom --wait" heroku config:edit`,
+];
+ConfigEdit.flags = {
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+};
+ConfigEdit.args = {
+    key: core_1.Args.string({ optional: true, description: 'edit a single key' }),
+};

package/lib/commands/config/get.d.ts

@@ -0,0 +1,16 @@
+import { Command } from '@heroku-cli/command';
+export declare class ConfigGet extends Command {
+    static usage: string;
+    static description: string;
+    static example: string;
+    static strict: boolean;
+    static args: {
+        KEY: import("@oclif/core/lib/interfaces/parser").Arg<string, Record<string, unknown>>;
+    };
+    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>;
+        shell: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/config/get.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigGet = void 0;
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const quote_1 = require("../../lib/config/quote");
+class ConfigGet extends command_1.Command {
+    async run() {
+        const { flags, argv } = await this.parse(ConfigGet);
+        const { body: config } = await this.heroku.get(`/apps/${flags.app}/config-vars`);
+        for (const key of argv) {
+            const v = config[key];
+            if (flags.shell) {
+                this.log(`${key}=${(0, quote_1.quote)(v || '')}`);
+            }
+            else {
+                this.log(v || '');
+            }
+        }
+    }
+}
+exports.ConfigGet = ConfigGet;
+ConfigGet.usage = 'config:get KEY...';
+ConfigGet.description = 'display a single config value for an app';
+ConfigGet.example = `$ heroku config:get RAILS_ENV
+production`;
+ConfigGet.strict = false;
+ConfigGet.args = {
+    KEY: core_1.Args.string({ required: true }),
+};
+ConfigGet.flags = {
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+    shell: command_1.flags.boolean({ char: 's', description: 'output config vars in shell format' }),
+};

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

@@ -0,0 +1,11 @@
+import { Command } from '@heroku-cli/command';
+export declare class ConfigIndex 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>;
+        shell: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/config/index.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigIndex = void 0;
+const color_1 = require("@heroku-cli/color");
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const _ = require("lodash");
+const quote_1 = require("../../lib/config/quote");
+class ConfigIndex extends command_1.Command {
+    async run() {
+        const { flags } = await this.parse(ConfigIndex);
+        const { body: config } = await this.heroku.get(`/apps/${flags.app}/config-vars`);
+        if (flags.shell) {
+            Object.entries(config)
+                .forEach(([k, v]) => core_1.ux.log(`${k}=${(0, quote_1.quote)(v)}`));
+        }
+        else if (flags.json) {
+            core_1.ux.styledJSON(config);
+        }
+        else {
+            core_1.ux.styledHeader(`${flags.app} Config Vars`);
+            core_1.ux.styledObject(_.mapKeys(config, (_, k) => color_1.default.configVar(k)));
+        }
+    }
+}
+exports.ConfigIndex = ConfigIndex;
+ConfigIndex.description = 'display the config vars for an app';
+ConfigIndex.flags = {
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+    shell: command_1.flags.boolean({ char: 's', description: 'output config vars in shell format' }),
+    json: command_1.flags.boolean({ char: 'j', description: 'output config vars in json format' }),
+};

package/lib/commands/config/unset.d.ts

@@ -0,0 +1,12 @@
+import { Command } from '@heroku-cli/command';
+export declare class ConfigUnset extends Command {
+    static aliases: string[];
+    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>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/config/unset.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigUnset = void 0;
+const color_1 = require("@heroku-cli/color");
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const _ = require("lodash");
+class ConfigUnset extends command_1.Command {
+    async run() {
+        const parsed = await this.parse(ConfigUnset);
+        const { flags } = parsed;
+        const argv = parsed.argv;
+        const lastRelease = async () => {
+            const { body: releases } = await this.heroku.get(`/apps/${flags.app}/releases`, {
+                partial: true,
+                headers: { Range: 'version ..; order=desc,max=1' },
+            });
+            return releases[0];
+        };
+        if (argv.length === 0) {
+            this.error('Usage: heroku config:unset KEY1 [KEY2 ...]\nMust specify KEY to unset.');
+        }
+        const vars = argv.map(v => color_1.default.configVar(v)).join(', ');
+        core_1.ux.action.start(`Unsetting ${vars} and restarting ${color_1.default.app(flags.app)}`);
+        await this.heroku.patch(`/apps/${flags.app}/config-vars`, {
+            // body will be like {FOO: null, BAR: null}
+            body: _.reduce(argv, (vars, v) => {
+                vars[v] = null;
+                return vars;
+            }, {}),
+        });
+        const release = await lastRelease();
+        core_1.ux.action.stop('done, ' + color_1.default.release(`v${release.version}`));
+    }
+}
+exports.ConfigUnset = ConfigUnset;
+ConfigUnset.aliases = [
+    'config:remove',
+];
+ConfigUnset.description = 'unset one or more config vars';
+ConfigUnset.examples = [
+    `$ heroku config:unset RAILS_ENV
+Unsetting RAILS_ENV and restarting example... done, v10`,
+    `$ heroku config:unset RAILS_ENV RACK_ENV
+Unsetting RAILS_ENV, RACK_ENV and restarting example... done, v10`,
+];
+ConfigUnset.strict = false;
+ConfigUnset.flags = {
+    app: command_1.flags.app({ char: 'a', required: true }),
+    remote: command_1.flags.remote({ char: 'r' }),
+};

package/lib/commands/console.d.ts

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

package/lib/commands/console.js

@@ -0,0 +1,30 @@
+"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 dyno_1 = require("../lib/run/dyno");
+const helpers_1 = require("../lib/run/helpers");
+class RunConsole extends command_1.Command {
+    async run() {
+        const { flags } = await this.parse(RunConsole);
+        const opts = {
+            heroku: this.heroku,
+            app: flags.app,
+            command: (0, helpers_1.buildCommand)(['console']),
+            size: flags.size,
+            env: flags.env,
+            attach: true,
+        };
+        const dyno = new dyno_1.default(opts);
+        await dyno.start();
+    }
+}
+exports.default = RunConsole;
+RunConsole.hidden = true;
+RunConsole.flags = {
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+    size: command_1.flags.string({ char: 's', description: 'dyno size', completion: completions_1.DynoSizeCompletion }),
+    env: command_1.flags.string({ char: 'e', description: 'environment variables to set (use \';\' to split multiple vars)' }),
+};

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

@@ -0,0 +1,19 @@
+import { Command } from '@heroku-cli/command';
+import * as Heroku from '@heroku-cli/schema';
+export default class DomainsAdd extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        help: import("@oclif/core/lib/interfaces").BooleanFlag<void>;
+        app: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        cert: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        wait: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        remote: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+    };
+    static args: {
+        hostname: import("@oclif/core/lib/interfaces/parser").Arg<string, Record<string, unknown>>;
+    };
+    certSelect: (certs: Array<Heroku.SniEndpoint>) => Promise<string>;
+    run(): Promise<void>;
+}

package/lib/commands/domains/add.js

@@ -0,0 +1,117 @@
+"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 spinner_1 = require("@oclif/core/lib/cli-ux/action/spinner");
+const inquirer_1 = require("inquirer");
+const shellescape = require("shell-escape");
+const wait_for_domain_1 = require("../../lib/domains/wait-for-domain");
+class DomainsAdd extends command_1.Command {
+    constructor() {
+        super(...arguments);
+        this.certSelect = async (certs) => {
+            const nullCertChoice = {
+                name: 'No SNI Endpoint',
+                value: null,
+            };
+            const certChoices = certs.map((cert) => {
+                const certName = cert.displayName || cert.name;
+                const domainsLength = cert.ssl_cert.cert_domains.length;
+                if (domainsLength) {
+                    let domainsList = cert.ssl_cert.cert_domains.slice(0, 4).join(', ');
+                    if (domainsLength > 5) {
+                        domainsList = `${domainsList} (...and ${domainsLength - 4} more)`;
+                    }
+                    domainsList = `${certName} -> ${domainsList}`;
+                    return {
+                        name: domainsList,
+                        value: cert.name,
+                    };
+                }
+                return {
+                    name: certName,
+                    value: cert.name,
+                };
+            });
+            const selection = await (0, inquirer_1.prompt)([
+                {
+                    type: 'list',
+                    name: 'cert',
+                    message: 'Choose an SNI endpoint to associate with this domain',
+                    choices: [nullCertChoice, ...certChoices],
+                },
+            ]);
+            return selection.cert;
+        };
+    }
+    async run() {
+        const { args, flags } = await this.parse(DomainsAdd);
+        const { hostname } = args;
+        const action = new spinner_1.default();
+        const domainCreatePayload = {
+            hostname,
+            sni_endpoint: null,
+        };
+        let certs = [];
+        action.start(`Adding ${color_1.color.green(domainCreatePayload.hostname)} to ${color_1.color.app(flags.app)}`);
+        if (flags.cert) {
+            domainCreatePayload.sni_endpoint = flags.cert;
+        }
+        else {
+            const { body } = await this.heroku.get(`/apps/${flags.app}/sni-endpoints`);
+            certs = [...body];
+        }
+        if (certs.length > 1) {
+            action.stop('resolving SNI endpoint');
+            const certSelection = await this.certSelect(certs);
+            if (certSelection) {
+                domainCreatePayload.sni_endpoint = certSelection;
+            }
+            action.start(`Adding ${color_1.color.green(domainCreatePayload.hostname)} to ${color_1.color.app(flags.app)}`);
+        }
+        try {
+            const { body: domain } = await this.heroku.post(`/apps/${flags.app}/domains`, {
+                body: domainCreatePayload,
+            });
+            if (flags.json) {
+                core_1.ux.styledJSON(domain);
+            }
+            else {
+                core_1.ux.log(`Configure your app's DNS provider to point to the DNS Target ${color_1.color.green(domain.cname || '')}.
+    For help, see https://devcenter.heroku.com/articles/custom-domains`);
+                if (domain.status !== 'none') {
+                    if (flags.wait) {
+                        await (0, wait_for_domain_1.default)(flags.app, this.heroku, domain);
+                    }
+                    else {
+                        core_1.ux.log('');
+                        core_1.ux.log(`The domain ${color_1.color.green(hostname)} has been enqueued for addition`);
+                        const command = `heroku domains:wait ${shellescape([hostname])}`;
+                        core_1.ux.log(`Run ${color_1.color.cmd(command)} to wait for completion`);
+                    }
+                }
+            }
+        }
+        catch (error) {
+            core_1.ux.error(error);
+        }
+        finally {
+            action.stop();
+        }
+    }
+}
+exports.default = DomainsAdd;
+DomainsAdd.description = 'add a domain to an app';
+DomainsAdd.examples = ['heroku domains:add www.example.com'];
+DomainsAdd.flags = {
+    help: command_1.flags.help({ char: 'h' }),
+    app: command_1.flags.app({ required: true }),
+    cert: command_1.flags.string({ description: 'the name of the SSL cert you want to use for this domain', char: 'c' }),
+    json: command_1.flags.boolean({ description: 'output in json format', char: 'j' }),
+    wait: command_1.flags.boolean(),
+    remote: command_1.flags.remote(),
+};
+DomainsAdd.args = {
+    hostname: core_1.Args.string({ required: true }),
+};

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

@@ -0,0 +1,11 @@
+import { Command } from '@heroku-cli/command';
+export default class DomainsClear extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        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>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/domains/clear.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const color_1 = require("@heroku-cli/color");
+const command_1 = require("@heroku-cli/command");
+const spinner_1 = require("@oclif/core/lib/cli-ux/action/spinner");
+class DomainsClear extends command_1.Command {
+    async run() {
+        const { flags } = await this.parse(DomainsClear);
+        const action = new spinner_1.default();
+        action.start(`Removing all domains from ${color_1.color.app(flags.app)}`);
+        let { body: domains } = await this.heroku.get(`/apps/${flags.app}/domains`);
+        domains = domains.filter((d) => d.kind === 'custom');
+        for (const domain of domains) {
+            await this.heroku.delete(`/apps/${flags.app}/domains/${domain.hostname}`);
+        }
+        action.stop();
+    }
+}
+exports.default = DomainsClear;
+DomainsClear.description = 'remove all domains from an app';
+DomainsClear.examples = ['heroku domains:clear'];
+DomainsClear.flags = {
+    help: command_1.flags.help({ char: 'h' }),
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+};

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

@@ -0,0 +1,40 @@
+import { Command } from '@heroku-cli/command';
+import * as Heroku from '@heroku-cli/schema';
+export default class DomainsIndex extends Command {
+    static description: string;
+    static examples: string[];
+    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>;
+        columns: 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>;
+        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>;
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    tableConfig: (needsEndpoints: boolean) => {
+        hostname: {
+            header: string;
+        };
+        kind: {
+            header: string;
+            get: (domain: Heroku.Domain) => "ALIAS or ANAME" | "CNAME" | undefined;
+        };
+        cname: {
+            header: string;
+        };
+        acm_status: {
+            header: string;
+            extended: boolean;
+        };
+        acm_status_reason: {
+            header: string;
+            extended: boolean;
+        };
+    };
+    run(): Promise<void>;
+}

package/lib/commands/domains/index.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const Uri = require("urijs");
+function isApexDomain(hostname) {
+    if (hostname.includes('*'))
+        return false;
+    const a = new Uri({ protocol: 'http', hostname });
+    return a.subdomain() === '';
+}
+class DomainsIndex extends command_1.Command {
+    constructor() {
+        super(...arguments);
+        this.tableConfig = (needsEndpoints) => {
+            const tableConfig = {
+                hostname: {
+                    header: 'Domain Name',
+                },
+                kind: {
+                    header: 'DNS Record Type',
+                    get: (domain) => {
+                        if (domain.hostname) {
+                            return isApexDomain(domain.hostname) ? 'ALIAS or ANAME' : 'CNAME';
+                        }
+                    },
+                },
+                cname: { header: 'DNS Target' },
+                acm_status: { header: 'ACM Status', extended: true },
+                acm_status_reason: { header: 'ACM Status', extended: true },
+            };
+            const sniConfig = {
+                sni_endpoint: {
+                    header: 'SNI Endpoint',
+                    get: (domain) => {
+                        if (domain.sni_endpoint) {
+                            return domain.sni_endpoint.name;
+                        }
+                    },
+                },
+            };
+            if (needsEndpoints) {
+                return Object.assign(Object.assign({}, tableConfig), sniConfig);
+            }
+            return tableConfig;
+        };
+    }
+    async run() {
+        const { flags } = await this.parse(DomainsIndex);
+        const { body: domains } = await this.heroku.get(`/apps/${flags.app}/domains`);
+        const herokuDomain = domains.find(domain => domain.kind === 'heroku');
+        const customDomains = domains.filter(domain => domain.kind === 'custom');
+        if (flags.json) {
+            core_1.ux.styledJSON(domains);
+        }
+        else {
+            core_1.ux.styledHeader(`${flags.app} Heroku Domain`);
+            core_1.ux.log(herokuDomain && herokuDomain.hostname);
+            if (customDomains && customDomains.length > 0) {
+                core_1.ux.log();
+                core_1.ux.styledHeader(`${flags.app} Custom Domains`);
+                core_1.ux.table(customDomains, this.tableConfig(true), Object.assign(Object.assign({}, flags), { 'no-truncate': true }));
+            }
+        }
+    }
+}
+exports.default = DomainsIndex;
+DomainsIndex.description = 'list domains for an app';
+DomainsIndex.examples = [
+    `$ heroku domains
+=== example Heroku Domain
+example-xxxxxxxxxxxx.herokuapp.com
+
+=== example Custom Domains
+Domain Name      DNS Record Type  DNS Target
+www.example.com  CNAME            www.example.herokudns.com
+`, "$ heroku domains --filter 'Domain Name=www.example.com'",
+];
+DomainsIndex.flags = Object.assign({ help: command_1.flags.help({ char: 'h' }), app: command_1.flags.app({ required: true }), remote: command_1.flags.remote(), json: command_1.flags.boolean({ description: 'output in json format', char: 'j' }) }, core_1.ux.table.flags({ except: 'no-truncate' }));

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

@@ -0,0 +1,14 @@
+import { Command } from '@heroku-cli/command';
+export default class DomainsInfo extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        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>;
+    };
+    static args: {
+        hostname: import("@oclif/core/lib/interfaces/parser").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}