heroku 11.0.0-alpha.11 → 11.0.0-alpha.13

package/lib/commands/container/run.js

@@ -1,31 +1,31 @@
+import { color, hux } from '@heroku/heroku-cli-util';
 import { Command, flags } from '@heroku-cli/command';
 import { ux } from '@oclif/core';
-import { hux } from '@heroku/heroku-cli-util';
+import { debug } from '../../lib/container/debug.js';
 import { DockerHelper } from '../../lib/container/docker_helper.js';
 import { ensureContainerStack } from '../../lib/container/helpers.js';
-import { debug } from '../../lib/container/debug.js';
-import { color } from '@heroku-cli/color';
 export default class Run extends Command {
-    static topic = 'container';
     static description = 'builds, then runs the docker image locally';
-    static usage = 'container:run -a APP [-v] PROCESS_TYPE...';
-    static example = `
-  ${color.cmd('$ heroku container:pull web')}        # Pulls the web image from the app
-  ${color.cmd('$ heroku container:pull web worker')} # Pulls both the web and worker images from the app
-  ${color.cmd('$ heroku container:pull web:latest')} # Pulls the latest tag from the web image`;
-    static strict = false;
+    static examples = [
+        `${color.command('heroku container:pull web')}        # Pulls the web image from the app`,
+        `${color.command('heroku container:pull web worker')} # Pulls both the web and worker images from the app`,
+        `${color.command('heroku container:pull web:latest')} # Pulls the latest tag from the web image`,
+    ];
     static flags = {
         app: flags.app({ required: true }),
+        port: flags.integer({ char: 'p', default: 5000, description: 'port the app will run on' }),
         remote: flags.remote(),
-        port: flags.integer({ char: 'p', description: 'port the app will run on', default: 5000 }),
         verbose: flags.boolean({ char: 'v' }),
     };
+    static strict = false;
+    static topic = 'container';
+    static usage = 'container:run -a APP [-v] PROCESS_TYPE...';
     dockerHelper = new DockerHelper();
     async run() {
         const { argv, flags } = await this.parse(Run);
-        const { verbose, app, port } = flags;
+        const { app, port, verbose } = flags;
         if (argv.length === 0) {
-            this.error(`Error: Requires one process type\n${Run.example}`);
+            this.error(`Error: Requires one process type\n${Run.examples.join('\n')}`);
         }
         if (verbose) {
             debug.enabled = true;
@@ -53,7 +53,7 @@ export default class Run extends Command {
             hux.styledHeader(`Running ${job.resource}`);
         }
         else {
-            hux.styledHeader(`Running '${command}' on ${job.resource}`);
+            hux.styledHeader(`Running '${color.code(command)}' on ${job.resource}`);
         }
         try {
             await this.dockerHelper.runImage(job.resource, command, port);

package/lib/commands/dashboard.d.ts

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

package/lib/commands/dashboard.js

@@ -1,14 +1,13 @@
-import { color } from '@heroku-cli/color';
+import { color, hux } from '@heroku/heroku-cli-util';
 import { Command } from '@heroku-cli/command';
 import { ux } from '@oclif/core';
+import { execSync } from 'child_process';
 import _ from 'lodash';
-import img from 'term-img';
 import * as path from 'path';
-import { execSync } from 'child_process';
-import { sparkline } from '../lib/utils/sparkline.js';
-import { ago } from '../lib/time.js';
 import * as process from 'process';
-import { hux } from '@heroku/heroku-cli-util';
+import img from 'term-img';
+import { ago } from '../lib/time.js';
+import { sparkline } from '../lib/utils/sparkline.js';
 const empty = (o) => Object.keys(o).length === 0;
 function displayFormation(formation) {
     formation = _.groupBy(formation, 'size');
@@ -19,17 +18,17 @@ function displayErrors(metrics) {
     let errors = [];
     if (metrics.routerErrors) {
         errors = errors.concat(Object.entries(metrics.routerErrors.data)
-            .map(e => color.red(`${_.sum(e[1])} ${e[0]}`)));
+            .map(e => color.failure(`${_.sum(e[1])} ${e[0]}`)));
     }
     if (metrics.dynoErrors) {
         metrics.dynoErrors.filter(Boolean)
             .forEach(dynoErrors => {
             errors = errors.concat(Object.entries(dynoErrors?.data || {})
-                .map(e => color.red(`${_.sum(e[1])} ${e[0]}`)));
+                .map(e => color.failure(`${_.sum(e[1])} ${e[0]}`)));
         });
     }
     if (errors.length > 0)
-        ux.stdout(`  ${label('Errors:')} ${errors.join(dim(', '))} (see details with ${color.cyan.bold('heroku apps:errors')})`);
+        ux.stdout(`  ${label('Errors:')} ${errors.join(dim(', '))} (see details with ${color.code('heroku apps:errors')})`);
 }
 function displayMetrics(metrics) {
     function rpmSparkline() {
@@ -64,12 +63,12 @@ function displayNotifications(notifications) {
         return;
     notifications = notifications.filter(n => !n.read);
     if (notifications.length > 0) {
-        ux.stdout(`\nYou have ${color.yellow(notifications.length.toString())} unread notifications. Read them with ${color.cyan.bold('heroku notifications')}`);
+        ux.stdout(`\nYou have ${color.yellow(notifications.length.toString())} unread notifications. Read them with ${color.code('heroku notifications')}`);
     }
 }
 const dim = (s) => color.dim(s);
 const bold = (s) => color.bold(s);
-const label = (s) => color.heroku(s);
+const label = (s) => color.label(s);
 const fetchMetrics = async (apps, heroku) => {
     const NOW = new Date().toISOString();
     const YESTERDAY = new Date(Date.now() - (24 * 60 * 60 * 1000)).toISOString();
@@ -85,7 +84,7 @@ const fetchMetrics = async (apps, heroku) => {
         ]);
     }));
     return metricsData.map(([dynoErrors, routerLatency, routerErrors, routerStatus]) => ({
-        dynoErrors, routerLatency: routerLatency?.body, routerErrors: routerErrors?.body, routerStatus: routerStatus?.body,
+        dynoErrors, routerErrors: routerErrors?.body, routerLatency: routerLatency?.body, routerStatus: routerStatus?.body,
     }));
 };
 function displayApps(apps, appsMetrics) {
@@ -95,9 +94,9 @@ function displayApps(apps, appsMetrics) {
         const app = a[0];
         const metrics = a[1];
         hux.styledHeader(color.app(app.app.name || ''));
-        ux.stdout(`  ${label('Owner:')} ${getOwner(app.app.owner)}`);
+        ux.stdout(`  ${label('Owner:')} ${color.user(getOwner(app.app.owner) || '')}`);
         if (app.pipeline) {
-            ux.stdout(`  ${label('Pipeline:')} ${app.pipeline.pipeline?.name}`);
+            ux.stdout(`  ${label('Pipeline:')} ${color.pipeline(app.pipeline.pipeline?.name || '')}`);
         }
         displayFormation(app.formation);
         ux.stdout(`  ${label('Last release:')} ${ago(new Date(app.app.released_at || ''))}`);
@@ -107,9 +106,9 @@ function displayApps(apps, appsMetrics) {
     }
 }
 export default class Dashboard extends Command {
-    static topic = 'dashboard';
     static description = 'display information about favorite apps';
     static hidden = true;
+    static topic = 'dashboard';
     async run() {
         if (!this.heroku.auth && process.env.IS_HEROKU_TEST_ENV !== 'true') {
             execSync('heroku help', { stdio: 'inherit' });
@@ -148,13 +147,13 @@ export default class Dashboard extends Command {
         if (apps.length > 0)
             displayApps(appsWithMoreInfo, metrics);
         else
-            ux.warn(`Add apps to this dashboard by favoriting them with ${color.cmd('heroku apps:favorites:add')}`);
-        ux.stdout(`See all add-ons with ${color.cmd('heroku addons')}`);
+            ux.warn(`Add apps to this dashboard by favoriting them with ${color.code('heroku apps:favorites:add')}`);
+        ux.stdout(`See all add-ons with ${color.code('heroku addons')}`);
         const sampleTeam = _.sortBy(teams.filter(o => o.role !== 'collaborator'), o => new Date(o.created_at || ''))[0];
         if (sampleTeam)
-            ux.stdout(`See all apps in ${color.magenta(sampleTeam.name || '')} with ${color.cmd('heroku apps --team ' + sampleTeam.name)}`);
-        ux.stdout(`See all apps with ${color.cmd('heroku apps --all')}`);
+            ux.stdout(`See all apps in ${color.team(sampleTeam.name || '')} with ${color.code('heroku apps --team ' + sampleTeam.name)}`);
+        ux.stdout(`See all apps with ${color.code('heroku apps --all')}`);
         displayNotifications(notificationsResponse?.body);
-        ux.stdout(`\nSee other CLI commands with ${color.cmd('heroku help')}\n`);
+        ux.stdout(`\nSee other CLI commands with ${color.code('heroku help')}\n`);
     }
 }

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

@@ -2,20 +2,20 @@ import { Command } from '@heroku-cli/command';
 import * as Heroku from '@heroku-cli/schema';
 declare type CertChoice = {
     name: string;
-    value: string | null | undefined;
+    value: null | string | undefined;
 };
 export default class DomainsAdd extends Command {
+    static args: {
+        hostname: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
     static description: string;
     static examples: string[];
     static flags: {
         app: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
         cert: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
-        wait: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         remote: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
-    };
-    static args: {
-        hostname: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+        wait: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     certSelect: (certs: Array<Heroku.SniEndpoint>) => Promise<string>;
     promptForCert(nullCertChoice: CertChoice, certChoices: CertChoice[]): Promise<string>;

package/lib/commands/domains/add.js

@@ -1,22 +1,21 @@
-import { color } from '@heroku-cli/color';
+import { color, hux } from '@heroku/heroku-cli-util';
 import { Command, flags } from '@heroku-cli/command';
 import { Args, ux } from '@oclif/core';
-import { hux } from '@heroku/heroku-cli-util';
 import inquirer from 'inquirer';
 import { quote } from '../../lib/config/quote.js';
 import waitForDomain from '../../lib/domains/wait-for-domain.js';
 export default class DomainsAdd extends Command {
+    static args = {
+        hostname: Args.string({ description: 'unique identifier of the domain or full hostname', required: true }),
+    };
     static description = 'add a domain to an app';
-    static examples = ['heroku domains:add www.example.com'];
+    static examples = [`${color.command('heroku domains:add www.example.com')}`];
     static flags = {
         app: flags.app({ required: true }),
-        cert: flags.string({ description: 'the name of the SSL cert you want to use for this domain', char: 'c' }),
-        json: flags.boolean({ description: 'output in json format', char: 'j' }),
-        wait: flags.boolean(),
+        cert: flags.string({ char: 'c', description: 'the name of the SSL cert you want to use for this domain' }),
+        json: flags.boolean({ char: 'j', description: 'output in json format' }),
         remote: flags.remote(),
-    };
-    static args = {
-        hostname: Args.string({ required: true, description: 'unique identifier of the domain or full hostname' }),
+        wait: flags.boolean(),
     };
     certSelect = async (certs) => {
         const nullCertChoice = {
@@ -47,10 +46,10 @@ export default class DomainsAdd extends Command {
     async promptForCert(nullCertChoice, certChoices) {
         const selection = await inquirer.prompt([
             {
-                type: 'list',
-                name: 'cert',
-                message: 'Choose an SNI endpoint to associate with this domain',
                 choices: [nullCertChoice, ...certChoices],
+                message: 'Choose an SNI endpoint to associate with this domain',
+                name: 'cert',
+                type: 'list',
             },
         ]);
         return selection.cert;
@@ -63,7 +62,7 @@ export default class DomainsAdd extends Command {
             sni_endpoint: null,
         };
         let certs = [];
-        ux.action.start(`Adding ${color.green(domainCreatePayload.hostname)} to ${color.app(flags.app)}`);
+        ux.action.start(`Adding ${color.name(domainCreatePayload.hostname)} to ${color.app(flags.app)}`);
         if (flags.cert) {
             domainCreatePayload.sni_endpoint = flags.cert;
         }
@@ -77,7 +76,7 @@ export default class DomainsAdd extends Command {
             if (certSelection) {
                 domainCreatePayload.sni_endpoint = certSelection;
             }
-            ux.action.start(`Adding ${color.green(domainCreatePayload.hostname)} to ${color.app(flags.app)}`);
+            ux.action.start(`Adding ${color.name(domainCreatePayload.hostname)} to ${color.app(flags.app)}`);
         }
         try {
             const { body: domain } = await this.heroku.post(`/apps/${flags.app}/domains`, {
@@ -87,17 +86,17 @@ export default class DomainsAdd extends Command {
                 hux.styledJSON(domain);
             }
             else {
-                ux.stdout(`Configure your app's DNS provider to point to the DNS Target ${color.green(domain.cname || '')}.
-    For help, see https://devcenter.heroku.com/articles/custom-domains`);
+                ux.stdout(`Configure your app's DNS provider to point to the DNS Target ${color.name(domain.cname || '')}.
+    For help, see ${color.info('https://devcenter.heroku.com/articles/custom-domains')}`);
                 if (domain.status !== 'none') {
                     if (flags.wait) {
                         await waitForDomain(flags.app, this.heroku, domain);
                     }
                     else {
                         ux.stdout('');
-                        ux.stdout(`The domain ${color.green(hostname)} has been enqueued for addition`);
+                        ux.stdout(`The domain ${color.name(hostname)} has been enqueued for addition`);
                         const command = `heroku domains:wait ${quote(hostname)}`;
-                        ux.stdout(`Run ${color.cmd(command)} to wait for completion`);
+                        ux.stdout(`Run ${color.code(command)} to wait for completion`);
                     }
                 }
             }

package/lib/commands/domains/clear.js

@@ -1,9 +1,9 @@
-import { color } from '@heroku-cli/color';
+import { color } from '@heroku/heroku-cli-util';
 import { Command, flags } from '@heroku-cli/command';
 import { ux } from '@oclif/core';
 export default class DomainsClear extends Command {
     static description = 'remove all domains from an app';
-    static examples = ['heroku domains:clear'];
+    static examples = [`${color.command('heroku domains:clear')}`];
     static flags = {
         app: flags.app({ required: true }),
         remote: flags.remote(),

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

@@ -6,19 +6,21 @@ export default class DomainsIndex extends Command {
     static flags: {
         app: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
         columns: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        csv: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         extended: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         filter: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         remote: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         sort: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
     };
-    tableConfig: (needsEndpoints: boolean, extended: boolean, requestedColumns?: string[]) => Record<string, any>;
     getFilteredDomains: (filterKeyValue: string, domains: Array<Heroku.Domain>) => {
-        size: number;
         filteredDomains: Heroku.Domain[];
+        size: number;
     };
-    mapSortFieldToProperty: (sortField: string) => string;
     mapColumnHeadersToKeys: (columnHeaders: string[]) => string[];
+    mapSortFieldToProperty: (sortField: string) => string;
+    outputCSV: (customDomains: Heroku.Domain[], tableConfig: Record<string, any>, sortProperty?: string) => void;
+    tableConfig: (needsEndpoints: boolean, extended: boolean, requestedColumns?: string[]) => Record<string, any>;
     confirmDisplayAllDomains(customDomains: Heroku.Domain[]): Promise<boolean>;
     run(): Promise<void>;
 }

package/lib/commands/domains/index.js

@@ -1,38 +1,108 @@
+import { color, hux } from '@heroku/heroku-cli-util';
 import { Command, flags } from '@heroku-cli/command';
-import { color } from '@heroku-cli/color';
+import { confirm } from '@inquirer/prompts';
 import { ux } from '@oclif/core';
-import { hux } from '@heroku/heroku-cli-util';
+import { orderBy } from 'natural-orderby';
 import Uri from 'urijs';
-import { confirm } from '@inquirer/prompts';
-import { paginateRequest } from '../../lib/utils/paginator.js';
 import parseKeyValue from '../../lib/utils/keyValueParser.js';
+import { paginateRequest } from '../../lib/utils/paginator.js';
 function isApexDomain(hostname) {
     if (hostname.includes('*'))
         return false;
-    const a = new Uri({ protocol: 'http', hostname });
+    const a = new Uri({ hostname, protocol: 'http' });
     return a.subdomain() === '';
 }
 export default class DomainsIndex extends Command {
     static description = 'list domains for an app';
-    static examples = [
-        `$ heroku domains
+    static examples = [`${color.command('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'",
-    ];
+`, `${color.command("heroku domains --filter 'Domain Name=www.example.com'")}
+=== example Custom Domains
+Domain Name      DNS Record Type  DNS Target
+www.example.com  CNAME            www.example.herokudns.com`];
     static flags = {
         app: flags.app({ required: true }),
         columns: flags.string({ description: 'only show provided columns (comma-separated)' }),
-        extended: flags.boolean({ description: 'show extra columns', char: 'x' }),
+        csv: flags.boolean({ char: 'c', description: 'output in csv format' }),
+        extended: flags.boolean({ char: 'x', description: 'show extra columns' }),
         filter: flags.string({ description: 'filter property by partial string matching, ex: name=foo' }),
-        json: flags.boolean({ description: 'output in json format', char: 'j' }),
+        json: flags.boolean({ char: 'j', description: 'output in json format' }),
         remote: flags.remote(),
         sort: flags.string({ description: 'sort by property' }),
     };
+    getFilteredDomains = (filterKeyValue, domains) => {
+        const filteredInfo = { filteredDomains: domains, size: 0 };
+        const { key: filterName, value } = parseKeyValue(filterKeyValue);
+        if (!value) {
+            throw new Error('Filter flag has an invalid value');
+        }
+        if (filterName === 'Domain Name') {
+            filteredInfo.filteredDomains = domains.filter(domain => domain.hostname.includes(value));
+        }
+        if (filterName === 'DNS Record Type') {
+            filteredInfo.filteredDomains = domains.filter(domain => {
+                const kind = isApexDomain(domain.hostname) ? 'ALIAS or ANAME' : 'CNAME';
+                return kind.includes(value);
+            });
+        }
+        if (filterName === 'DNS Target') {
+            filteredInfo.filteredDomains = domains.filter(domain => domain.cname.includes(value));
+        }
+        if (filterName === 'SNI Endpoint') {
+            filteredInfo.filteredDomains = domains.filter(domain => {
+                if (!domain.sni_endpoint)
+                    domain.sni_endpoint = '';
+                return domain.sni_endpoint.includes(value);
+            });
+        }
+        filteredInfo.size = filteredInfo.filteredDomains.length;
+        return filteredInfo;
+    };
+    mapColumnHeadersToKeys = (columnHeaders) => {
+        const headerToKeyMap = {
+            'ACM Status': 'acm_status',
+            'DNS Record Type': 'kind',
+            'DNS Target': 'cname',
+            'Domain Name': 'hostname',
+            'SNI Endpoint': 'sni_endpoint',
+        };
+        return columnHeaders.map(header => headerToKeyMap[header.trim()] || header.trim());
+    };
+    mapSortFieldToProperty = (sortField) => {
+        const headerToPropertyMap = {
+            'ACM Status': 'acm_status',
+            'DNS Record Type': 'kind',
+            'DNS Target': 'cname',
+            'Domain Name': 'hostname',
+            'SNI Endpoint': 'sni_endpoint',
+        };
+        return headerToPropertyMap[sortField] || sortField;
+    };
+    outputCSV = (customDomains, tableConfig, sortProperty) => {
+        const getValue = (domain, key, config) => {
+            const columnConfig = config ?? tableConfig[key];
+            return columnConfig?.get?.(domain) ?? domain[key] ?? '';
+        };
+        const escapeCSV = (value) => {
+            const needsEscaping = /["\n\r,]/.test(value);
+            return needsEscaping ? `"${value.replaceAll('"', '""')}"` : value;
+        };
+        const columns = Object.entries(tableConfig);
+        const columnHeaders = columns.map(([key, config]) => config.header || key);
+        ux.stdout(columnHeaders.join(','));
+        if (sortProperty) {
+            customDomains = orderBy(customDomains, [domain => getValue(domain, sortProperty)], ['asc']);
+        }
+        for (const domain of customDomains) {
+            const row = columns.map(([key, config]) => escapeCSV(getValue(domain, key, config)));
+            ux.stdout(row.join(','));
+        }
+    };
     tableConfig = (needsEndpoints, extended, requestedColumns) => {
         const tableConfig = {
             hostname: {
@@ -46,6 +116,7 @@ www.example.com  CNAME            www.example.herokudns.com
                 },
                 header: 'DNS Record Type',
             },
+            // eslint-disable-next-line perfectionist/sort-objects
             cname: { header: 'DNS Target' },
         };
         if (extended) {
@@ -54,12 +125,12 @@ www.example.com  CNAME            www.example.herokudns.com
         }
         const sniConfig = {
             sni_endpoint: {
-                header: 'SNI Endpoint',
                 get(domain) {
                     if (domain.sni_endpoint) {
                         return domain.sni_endpoint.name;
                     }
                 },
+                header: 'SNI Endpoint',
             },
         };
         let fullConfig = tableConfig;
@@ -81,54 +152,6 @@ www.example.com  CNAME            www.example.herokudns.com
         }
         return fullConfig;
     };
-    getFilteredDomains = (filterKeyValue, domains) => {
-        const filteredInfo = { size: 0, filteredDomains: domains };
-        const { key: filterName, value } = parseKeyValue(filterKeyValue);
-        if (!value) {
-            throw new Error('Filter flag has an invalid value');
-        }
-        if (filterName === 'Domain Name') {
-            filteredInfo.filteredDomains = domains.filter(domain => domain.hostname.includes(value));
-        }
-        if (filterName === 'DNS Record Type') {
-            filteredInfo.filteredDomains = domains.filter(domain => {
-                const kind = isApexDomain(domain.hostname) ? 'ALIAS or ANAME' : 'CNAME';
-                return kind.includes(value);
-            });
-        }
-        if (filterName === 'DNS Target') {
-            filteredInfo.filteredDomains = domains.filter(domain => domain.cname.includes(value));
-        }
-        if (filterName === 'SNI Endpoint') {
-            filteredInfo.filteredDomains = domains.filter(domain => {
-                if (!domain.sni_endpoint)
-                    domain.sni_endpoint = '';
-                return domain.sni_endpoint.includes(value);
-            });
-        }
-        filteredInfo.size = filteredInfo.filteredDomains.length;
-        return filteredInfo;
-    };
-    mapSortFieldToProperty = (sortField) => {
-        const headerToPropertyMap = {
-            'Domain Name': 'hostname',
-            'DNS Record Type': 'kind',
-            'DNS Target': 'cname',
-            'SNI Endpoint': 'sni_endpoint',
-            'ACM Status': 'acm_status',
-        };
-        return headerToPropertyMap[sortField] || sortField;
-    };
-    mapColumnHeadersToKeys = (columnHeaders) => {
-        const headerToKeyMap = {
-            'Domain Name': 'hostname',
-            'DNS Record Type': 'kind',
-            'DNS Target': 'cname',
-            'SNI Endpoint': 'sni_endpoint',
-            'ACM Status': 'acm_status',
-        };
-        return columnHeaders.map(header => headerToKeyMap[header.trim()] || header.trim());
-    };
     async confirmDisplayAllDomains(customDomains) {
         return confirm({ default: false, message: `Display all ${customDomains.length} domains?`, theme: { prefix: '', style: { defaultAnswer: () => '(Y/N)' } } });
     }
@@ -145,23 +168,30 @@ www.example.com  CNAME            www.example.herokudns.com
             hux.styledJSON(domains);
         }
         else {
-            hux.styledHeader(`${flags.app} Heroku Domain`);
-            ux.stdout(herokuDomain && herokuDomain.hostname);
+            hux.styledHeader(`${color.app(flags.app)} Heroku Domain`);
+            ux.stdout(herokuDomain && color.info(herokuDomain.hostname));
             if (customDomains && customDomains.length > 0) {
                 ux.stdout();
-                if (customDomains.length > 100 && !flags.json) {
-                    ux.warn(`This app has over 100 domains. Your terminal may not be configured to display the total amount of domains. You can output domains in JSON format with: ${color.cmd('heroku domains -a example-app --json')}`);
+                if (customDomains.length > 100 && !flags.json && !flags.csv) {
+                    ux.warn(`This app has over 100 domains. Your terminal may not be configured to display the total amount of domains. You can export all domains into a CSV file with: ${color.code('heroku domains -a example-app --csv > example-file.csv')}`);
                     displayTotalDomains = await this.confirmDisplayAllDomains(customDomains);
                     if (!displayTotalDomains) {
                         return;
                     }
                 }
                 ux.stdout();
-                hux.styledHeader(`${flags.app} Custom Domains`);
-                hux.table(customDomains, this.tableConfig(true, flags.extended, flags.columns ? this.mapColumnHeadersToKeys(flags.columns.split(',')) : undefined), {
-                    overflow: 'wrap',
-                    sort: flags.sort ? { [this.mapSortFieldToProperty(flags.sort)]: 'asc' } : undefined,
-                });
+                hux.styledHeader(`${color.app(flags.app)} Custom Domains`);
+                const tableConfig = this.tableConfig(true, flags.extended, flags.columns ? this.mapColumnHeadersToKeys(flags.columns.split(',')) : undefined);
+                const sortProperty = this.mapSortFieldToProperty(flags.sort);
+                if (flags.csv) {
+                    this.outputCSV(customDomains, tableConfig, sortProperty);
+                }
+                else {
+                    hux.table(customDomains, tableConfig, {
+                        overflow: 'wrap',
+                        sort: flags.sort ? { [sortProperty]: 'asc' } : undefined,
+                    });
+                }
             }
         }
     }

package/lib/commands/domains/info.js

@@ -1,10 +1,11 @@
+import { color } from '@heroku/heroku-cli-util';
 import { Command, flags } from '@heroku-cli/command';
 import { Args } from '@oclif/core';
 import { hux } from '@heroku/heroku-cli-util';
 export default class DomainsInfo extends Command {
     static description = 'show detailed information for a domain on an app';
     static examples = [
-        '$ heroku domains:info www.example.com',
+        color.command('heroku domains:info www.example.com'),
     ];
     static flags = {
         app: flags.app({ required: true }),

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

@@ -1,13 +1,13 @@
 import { Command } from '@heroku-cli/command';
 export default class DomainsRemove extends Command {
+    static args: {
+        hostname: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
     static description: string;
     static examples: string[];
     static flags: {
         app: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
         remote: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
     };
-    static args: {
-        hostname: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
-    };
     run(): Promise<void>;
 }

package/lib/commands/domains/remove.js

@@ -1,16 +1,16 @@
-import { color } from '@heroku-cli/color';
+import { color } from '@heroku/heroku-cli-util';
 import { Command, flags } from '@heroku-cli/command';
 import { Args, ux } from '@oclif/core';
 export default class DomainsRemove extends Command {
+    static args = {
+        hostname: Args.string({ description: 'unique identifier of the domain or full hostname', required: true }),
+    };
     static description = 'remove a domain from an app';
-    static examples = ['heroku domains:remove www.example.com'];
+    static examples = [`${color.command('heroku domains:remove www.example.com')}`];
     static flags = {
         app: flags.app({ required: true }),
         remote: flags.remote(),
     };
-    static args = {
-        hostname: Args.string({ required: true, description: 'unique identifier of the domain or full hostname' }),
-    };
     async run() {
         const { args, flags } = await this.parse(DomainsRemove);
         ux.action.start(`Removing ${color.green(args.hostname)} from ${color.app(flags.app)}`);

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

@@ -1,14 +1,14 @@
 import { Command } from '@heroku-cli/command';
 export default class DomainsUpdate extends Command {
+    static args: {
+        hostname: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
     static description: string;
     static examples: string[];
     static flags: {
         app: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
-        remote: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         cert: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
-    };
-    static args: {
-        hostname: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+        remote: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
     };
     run(): Promise<void>;
 }