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

package/lib/commands/autocomplete/index.js

@@ -0,0 +1,65 @@
+import { color } from '@heroku/heroku-cli-util';
+import { flags } from '@heroku-cli/command';
+import { AppCompletion, PipelineCompletion, SpaceCompletion, TeamCompletion, } from '@heroku-cli/command/lib/completions.js';
+import { Args, ux } from '@oclif/core';
+import * as path from 'path';
+import { AutocompleteBase } from '../../lib/autocomplete/base.js';
+import { updateCache } from '../../lib/autocomplete/cache.js';
+import Create from './create.js';
+export default class Index extends AutocompleteBase {
+    static args = {
+        shell: Args.string({ description: 'shell type', required: false }),
+    };
+    static description = 'display autocomplete installation instructions';
+    static examples = [
+        color.command('heroku autocomplete'),
+        color.command('heroku autocomplete bash'),
+        color.command('heroku autocomplete zsh'),
+        color.command('heroku autocomplete --refresh-cache'),
+    ];
+    static flags = {
+        'refresh-cache': flags.boolean({ char: 'r', description: 'refresh cache only (ignores displaying instructions)' }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(Index);
+        const shell = args.shell || this.config.shell;
+        this.errorIfNotSupportedShell(shell);
+        ux.action.start('Building the autocomplete cache');
+        const create = new Create([], this.config);
+        await create.run();
+        await this.updateCache(AppCompletion, 'app');
+        await this.updateCache(PipelineCompletion, 'pipeline');
+        await this.updateCache(SpaceCompletion, 'space');
+        await this.updateCache(TeamCompletion, 'team');
+        ux.action.stop();
+        if (!flags['refresh-cache']) {
+            const { bin } = this.config;
+            const bashNote = 'If your terminal starts as a login shell you may need to print the init script into ~/.bash_profile or ~/.profile.';
+            const zshNote = `After sourcing, you can run \`${color.command('compaudit -D')}\` to ensure no permissions conflicts are present`;
+            const note = shell === 'zsh' ? zshNote : bashNote;
+            const tabStr = shell === 'bash' ? '<TAB><TAB>' : '<TAB>';
+            this.log(`
+${color.label(`Setup Instructions for ${bin.toUpperCase()} CLI Autocomplete ---`)}
+
+1) Add the autocomplete env var to your ${shell} profile and source it
+${color.command(`printf "$(${bin} autocomplete:script ${shell})" >> ~/.${shell}rc; source ~/.${shell}rc`)}
+
+NOTE: ${note}
+
+2) Test it out, e.g.:
+${color.command(`${bin} ${tabStr}`)}                 # Command completion
+${color.command(`${bin} apps:info --${tabStr}`)}     # Flag completion
+${color.command(`${bin} apps:info --app=${tabStr}`)} # Flag option completion
+
+Visit the autocomplete Dev Center doc at ${color.info('https://devcenter.heroku.com/articles/heroku-cli-autocomplete')}
+
+Enjoy!
+`);
+        }
+    }
+    async updateCache(completion, cacheKey) {
+        const cachePath = path.join(this.completionsCacheDir, cacheKey);
+        const options = await completion.options({ config: this.config });
+        await updateCache(cachePath, options);
+    }
+}

package/lib/commands/autocomplete/options.d.ts

@@ -0,0 +1,25 @@
+import { AutocompleteBase } from '../../lib/autocomplete/base.js';
+export default class Options extends AutocompleteBase {
+    static hidden: boolean;
+    static description: string;
+    static flags: {
+        app: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    static args: {
+        completion: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    parsedArgs: {
+        [name: string]: string;
+    };
+    parsedFlags: {
+        [name: string]: string;
+    };
+    run(): Promise<void>;
+    private processCommandLine;
+    private determineCompletion;
+    private fetchOptions;
+    private parsedFlagsWithEnvVars;
+    private throwError;
+    private findFlagFromWildArg;
+    private determineCmdState;
+}

package/lib/commands/autocomplete/options.js

@@ -0,0 +1,208 @@
+import { flags } from '@heroku-cli/command';
+import { Args } from '@oclif/core';
+import * as path from 'path';
+import { AutocompleteBase } from '../../lib/autocomplete/base.js';
+import { fetchCache } from '../../lib/autocomplete/cache.js';
+export default class Options extends AutocompleteBase {
+    static hidden = true;
+    static description = 'display arg or flag completion options (used internally by completion functions)';
+    static flags = {
+        app: flags.app({ required: false, hidden: true }),
+    };
+    static args = {
+        completion: Args.string({ strict: false }),
+    };
+    parsedArgs = {};
+    parsedFlags = {};
+    // helpful dictionary
+    //
+    // *args: refers to a Command's static args
+    // *argv: refers to the current execution's command line positional input
+    // Klass: (class) Command class
+    // completion: (object) object with data/methods to build/retrieve options from cache
+    // curPosition*: the current argv position the shell is trying to complete
+    // options: (string) white-space separated list of values for the shell to use for completion
+    async run() {
+        this.errorIfWindows();
+        // ex: heroku autocomplete:options 'heroku addons:destroy -a myapp myaddon'
+        try {
+            const commandStateVars = await this.processCommandLine();
+            const completion = this.determineCompletion(commandStateVars);
+            const options = await this.fetchOptions(completion);
+            if (options)
+                this.log(options);
+        }
+        catch (error) {
+            // write to ac log
+            await this.writeLogFile(error.message);
+        }
+    }
+    async processCommandLine() {
+        // find command id
+        const commandLineToComplete = this.argv[0].split(' ');
+        const id = commandLineToComplete[1];
+        // find Command
+        const C = this.config.findCommand(id);
+        let Klass;
+        if (C) {
+            Klass = await C.load();
+            // process Command state from command line data
+            const slicedArgv = commandLineToComplete.slice(2);
+            const [argsIndex, curPositionIsFlag, curPositionIsFlagValue] = this.determineCmdState(slicedArgv, Klass);
+            return { id, Klass, argsIndex, curPositionIsFlag, curPositionIsFlagValue, slicedArgv };
+        }
+        this.throwError(`Command ${id} not found`);
+    }
+    determineCompletion(commandStateVars) {
+        const { id, Klass, argsIndex, curPositionIsFlag, curPositionIsFlagValue, slicedArgv } = commandStateVars;
+        // setup empty cache completion vars to assign
+        let cacheKey;
+        let cacheCompletion;
+        // completing a flag/value? else completing an arg
+        if (curPositionIsFlag || curPositionIsFlagValue) {
+            const slicedArgvCount = slicedArgv.length;
+            const lastArgvArg = slicedArgv[slicedArgvCount - 1];
+            const previousArgvArg = slicedArgv[slicedArgvCount - 2];
+            const argvFlag = curPositionIsFlagValue ? previousArgvArg : lastArgvArg;
+            const { name, flag } = this.findFlagFromWildArg(argvFlag, Klass);
+            if (!flag)
+                this.throwError(`${argvFlag} is not a valid flag for ${id}`);
+            cacheKey = name || flag.name;
+            cacheCompletion = flag.completion;
+        }
+        else {
+            const cmdArgs = Klass.args || [];
+            // variable arg (strict: false)
+            if (!Klass.strict) {
+                cacheKey = cmdArgs[0] && cmdArgs[0].name.toLowerCase();
+                cacheCompletion = this.findCompletion(cacheKey, id);
+                if (!cacheCompletion)
+                    this.throwError(`Cannot complete variable arg position for ${id}`);
+            }
+            else if (argsIndex > cmdArgs.length - 1) {
+                this.throwError(`Cannot complete arg position ${argsIndex} for ${id}`);
+            }
+            else {
+                const arg = cmdArgs[argsIndex];
+                cacheKey = arg.name.toLowerCase();
+            }
+        }
+        // try to auto-populate the completion object
+        if (!cacheCompletion) {
+            cacheCompletion = this.findCompletion(cacheKey, id);
+        }
+        return { cacheKey, cacheCompletion };
+    }
+    async fetchOptions(cache) {
+        const { cacheCompletion, cacheKey } = cache;
+        const flags = await this.parsedFlagsWithEnvVars();
+        // build/retrieve & return options cache
+        if (cacheCompletion && cacheCompletion.options) {
+            const ctx = {
+                args: this.parsedArgs,
+                // special case for app & team env vars
+                flags,
+                argv: this.argv,
+                config: this.config,
+            };
+            // use cacheKey function or fallback to arg/flag name
+            const ckey = cacheCompletion.cacheKey ? await cacheCompletion.cacheKey(ctx) : null;
+            const key = ckey || cacheKey || 'unknown_key_error';
+            const flagCachePath = path.join(this.completionsCacheDir, key);
+            // build/retrieve cache
+            const duration = cacheCompletion.cacheDuration || 60 * 60 * 24; // 1 day
+            const opts = { cacheFn: () => cacheCompletion.options(ctx) };
+            const options = await fetchCache(flagCachePath, duration, opts);
+            // return options cache
+            return (options || []).join('\n');
+        }
+    }
+    async parsedFlagsWithEnvVars() {
+        const { flags } = await this.parse(Options);
+        return {
+            app: process.env.HEROKU_APP || flags.app,
+            team: process.env.HEROKU_TEAM || process.env.HEROKU_ORG,
+            ...this.parsedFlags,
+        };
+    }
+    throwError(msg) {
+        throw new Error(msg);
+    }
+    findFlagFromWildArg(wild, Klass) {
+        let name = wild.replace(/^-+/, '');
+        name = name.replace(/[=](.+)?$/, '');
+        const unknown = { flag: undefined, name: undefined };
+        if (!Klass.flags)
+            return unknown;
+        const CFlags = Klass.flags;
+        let flag = CFlags[name];
+        if (flag)
+            return { name, flag };
+        name = Object.keys(CFlags).find((k) => CFlags[k].char === name) || 'undefinedcommand';
+        flag = CFlags && CFlags[name];
+        if (flag)
+            return { name, flag };
+        return unknown;
+    }
+    determineCmdState(argv, Klass) {
+        const argNames = Object.keys(Klass.args || {});
+        let needFlagValueSatisfied = false;
+        let argIsFlag = false;
+        let argIsFlagValue = false;
+        let argsIndex = -1;
+        let flagName;
+        argv.filter(wild => {
+            if (wild.match(/^-(-)?/)) {
+                // we're a flag
+                argIsFlag = true;
+                // ignore me
+                const wildSplit = wild.split('=');
+                const key = wildSplit.length === 1 ? wild : wildSplit[0];
+                const { name, flag } = this.findFlagFromWildArg(key, Klass);
+                flagName = name;
+                // end ignore me
+                if (wildSplit.length === 1) {
+                    // we're a flag w/o a '=value'
+                    // (find flag & see if flag needs a value)
+                    if (flag && flag.type !== 'boolean') {
+                        // we're a flag who needs our value to be next
+                        argIsFlagValue = false;
+                        needFlagValueSatisfied = true;
+                        return false;
+                    }
+                }
+                // --app=my-app is considered a flag & not a flag value
+                // the shell's autocomplete handles partial value matching
+                // add parsedFlag
+                if (wildSplit.length === 2 && name)
+                    this.parsedFlags[name] = wildSplit[1];
+                // we're a flag who is satisfied
+                argIsFlagValue = false;
+                needFlagValueSatisfied = false;
+                return false;
+            }
+            // we're not a flag
+            argIsFlag = false;
+            if (needFlagValueSatisfied) {
+                // we're a flag value
+                // add parsedFlag
+                if (flagName)
+                    this.parsedFlags[flagName] = wild;
+                argIsFlagValue = true;
+                needFlagValueSatisfied = false;
+                return false;
+            }
+            // we're an arg!
+            // add parsedArgs
+            // TO-DO: how to handle variableArgs?
+            argsIndex += 1;
+            if (argsIndex < argNames.length) {
+                this.parsedArgs[argNames[argsIndex]] = wild;
+            }
+            argIsFlagValue = false;
+            needFlagValueSatisfied = false;
+            return true;
+        });
+        return [argsIndex, argIsFlag, argIsFlagValue];
+    }
+}

package/lib/commands/autocomplete/script.d.ts

@@ -0,0 +1,10 @@
+import { AutocompleteBase } from '../../lib/autocomplete/base.js';
+export default class Script extends AutocompleteBase {
+    static description: string;
+    static hidden: boolean;
+    static args: {
+        shell: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+    private get prefix();
+}

package/lib/commands/autocomplete/script.js

@@ -0,0 +1,20 @@
+import { Args } from '@oclif/core';
+import * as path from 'path';
+import { AutocompleteBase } from '../../lib/autocomplete/base.js';
+export default class Script extends AutocompleteBase {
+    static description = 'display autocomplete setup script for shell';
+    static hidden = true;
+    static args = {
+        shell: Args.string({ description: 'shell type', required: false }),
+    };
+    async run() {
+        const { args } = await this.parse(Script);
+        const shell = args.shell || this.config.shell;
+        this.errorIfNotSupportedShell(shell);
+        const shellUpcase = shell.toUpperCase();
+        this.log(`${this.prefix}HEROKU_AC_${shellUpcase}_SETUP_PATH=${path.join(this.autocompleteCacheDir, `${shell}_setup`)} && test -f $HEROKU_AC_${shellUpcase}_SETUP_PATH && source $HEROKU_AC_${shellUpcase}_SETUP_PATH;`);
+    }
+    get prefix() {
+        return `\n# ${this.config.bin} autocomplete setup\n`;
+    }
+}

package/lib/commands/buildpacks/index.js

@@ -1,8 +1,7 @@
+import { color, hux } from '@heroku/heroku-cli-util';
 import { Command, flags as Flags } from '@heroku-cli/command';
-import { hux } from '@heroku/heroku-cli-util';
-import { color } from '@heroku-cli/color';
-import { BuildpackCommand } from '../../lib/buildpacks/buildpacks.js';
 import { getGeneration } from '../../lib/apps/generation.js';
+import { BuildpackCommand } from '../../lib/buildpacks/buildpacks.js';
 export default class Index extends Command {
     static description = 'list the buildpacks on an app';
     static flags = {

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

@@ -1,13 +1,13 @@
 import { Command } from '@heroku-cli/command';
 export default class Remove extends Command {
+    static args: {
+        buildpack: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
     static description: 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>;
         index: import("@oclif/core/interfaces").OptionFlag<number | undefined, import("@oclif/core/interfaces").CustomOptions>;
-    };
-    static args: {
-        buildpack: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+        remote: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
     };
     run(): Promise<void>;
 }

package/lib/commands/buildpacks/remove.js

@@ -1,20 +1,21 @@
+import { color } from '@heroku/heroku-cli-util';
 import { Command, flags as Flags } from '@heroku-cli/command';
 import { Args, ux } from '@oclif/core';
 import { BuildpackCommand } from '../../lib/buildpacks/buildpacks.js';
 export default class Remove extends Command {
+    static args = {
+        buildpack: Args.string({
+            description: 'namespace/name of the buildpack',
+        }),
+    };
     static description = 'remove a buildpack set on the app';
     static flags = {
         app: Flags.app({ required: true }),
-        remote: Flags.remote(),
         index: Flags.integer({
-            description: 'the 1-based index of the URL to remove from the list of URLs',
             char: 'i',
+            description: 'the 1-based index of the URL to remove from the list of URLs',
         }),
-    };
-    static args = {
-        buildpack: Args.string({
-            description: 'namespace/name of the buildpack',
-        }),
+        remote: Flags.remote(),
     };
     async run() {
         const { args, flags } = await this.parse(Remove);
@@ -27,7 +28,7 @@ export default class Remove extends Command {
         }
         const buildpacks = await buildpackCommand.fetch(flags.app);
         if (buildpacks.length === 0) {
-            ux.error(`No buildpacks were found. Next release on ${flags.app} will detect buildpack normally.`, { exit: 1 });
+            ux.error(`No buildpacks were found. Next release on ${color.app(flags.app)} will detect buildpack normally.`, { exit: 1 });
         }
         let spliceIndex;
         if (flags.index) {

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

@@ -2,18 +2,19 @@ import { APIClient, Command } from '@heroku-cli/command';
 import inquirer from 'inquirer';
 import { SniEndpoint } from '../../lib/types/sni_endpoint.js';
 export default class Add extends Command {
-    static topic: string;
-    static strict: boolean;
+    static args: {
+        CRT: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+        KEY: 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: {
-        CRT: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
-        KEY: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
-    };
+    static strict: boolean;
+    static topic: string;
+    configureDomains(app: string, heroku: APIClient, cert: SniEndpoint): Promise<void>;
     getDomainsToAssociate(sniEndpoint: SniEndpoint): Promise<{
         domains: string[];
     }> & {
@@ -21,9 +22,8 @@ export default class Add extends Command {
             domains: string[];
         }>;
     };
-    configureDomains(app: string, heroku: APIClient, cert: SniEndpoint): Promise<void>;
+    run(): Promise<void>;
     selectDomains(domainOptions: string[]): Promise<{
         domains: string[];
     }>;
-    run(): Promise<void>;
 }

package/lib/commands/certs/add.js

@@ -1,41 +1,31 @@
-import { color } from '@heroku-cli/color';
+import { hux, color } 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 { waitForDomains } from '../../lib/certs/domains.js';
 import inquirer from 'inquirer';
-import { CertAndKeyManager } from '../../lib/certs/get_cert_and_key.js';
 import tsheredoc from 'tsheredoc';
 import { displayCertificateDetails } from '../../lib/certs/certificate_details.js';
+import { waitForDomains } from '../../lib/certs/domains.js';
+import { CertAndKeyManager } from '../../lib/certs/get_cert_and_key.js';
 const heredoc = tsheredoc.default;
 export default class Add extends Command {
-    static topic = 'certs';
-    static strict = true;
+    static args = {
+        CRT: Args.string({ description: 'absolute path of the certificate file on disk', required: true }),
+        KEY: Args.string({ description: 'absolute path of the key file on disk', required: true }),
+    };
     static description = `Add an SSL certificate to an app.
 
   Note: certificates with PEM encoding are also valid.
   `;
-    static examples = [
-        heredoc(`$ heroku certs:add example.com.crt example.com.key
+    static examples = [heredoc(`
+    ${color.command('heroku certs:add example.com.crt example.com.key')}
     If you require intermediate certificates, refer to this article on merging certificates to get a complete chain:
-    https://help.salesforce.com/s/articleView?id=000333504&type=1`),
-    ];
+    ${color.info('https://help.salesforce.com/s/articleView?id=000333504&type=1')}`)];
     static flags = {
         app: flags.app({ required: true }),
         remote: flags.remote(),
     };
-    static args = {
-        CRT: Args.string({ required: true, description: 'absolute path of the certificate file on disk' }),
-        KEY: Args.string({ required: true, description: 'absolute path of the key file on disk' }),
-    };
-    getDomainsToAssociate(sniEndpoint) {
-        return inquirer.prompt([{
-                type: 'checkbox',
-                name: 'domains',
-                message: 'Select domains',
-                choices: sniEndpoint.ssl_cert.cert_domains,
-            }]);
-    }
+    static strict = true;
+    static topic = 'certs';
     async configureDomains(app, heroku, cert) {
         const certDomains = cert.ssl_cert.cert_domains;
         const apiDomains = await waitForDomains(app, heroku);
@@ -49,20 +39,20 @@ export default class Add extends Command {
             })));
         }
     }
-    async selectDomains(domainOptions) {
+    getDomainsToAssociate(sniEndpoint) {
         return inquirer.prompt([{
-                type: 'checkbox',
-                name: 'domains',
+                choices: sniEndpoint.ssl_cert.cert_domains,
                 message: 'Select domains',
-                choices: domainOptions,
+                name: 'domains',
+                type: 'checkbox',
             }]);
     }
     async run() {
-        const { flags, args } = await this.parse(Add);
+        const { args, flags } = await this.parse(Add);
         const { app } = flags;
         const certManager = new CertAndKeyManager();
         const files = await certManager.getCertAndKey(args);
-        ux.action.start(`Adding SSL certificate to ${color.magenta(app)}`);
+        ux.action.start(`Adding SSL certificate to ${color.app(app)}`);
         const { body: sniEndpoint } = await this.heroku.post(`/apps/${app}/sni-endpoints`, {
             body: {
                 certificate_chain: files.crt.toString(),
@@ -73,6 +63,14 @@ export default class Add extends Command {
         displayCertificateDetails(sniEndpoint);
         await this.configureDomains(app, this.heroku, sniEndpoint);
     }
+    async selectDomains(domainOptions) {
+        return inquirer.prompt([{
+                choices: domainOptions,
+                message: 'Select domains',
+                name: 'domains',
+                type: 'checkbox',
+            }]);
+    }
 }
 function splitDomains(domains) {
     return domains.map(domain => [domain.slice(0, 1), domain.slice(1)]);
@@ -85,7 +83,7 @@ function createMatcherFromSplitDomain([firstChar, rest]) {
     else {
         matcherContents.push(firstChar);
     }
-    const escapedRest = rest.replace(/\./g, '\\.');
+    const escapedRest = rest.replaceAll('.', '\\.');
     matcherContents.push(escapedRest);
     return new RegExp(matcherContents.join(''));
 }

package/lib/commands/certs/auto/disable.d.ts

@@ -1,11 +1,11 @@
 import { Command } from '@heroku-cli/command';
 export default class Disable extends Command {
-    static topic: string;
     static description: string;
     static flags: {
-        confirm: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         app: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        confirm: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         remote: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
     };
+    static topic: string;
     run(): Promise<void>;
 }

package/lib/commands/certs/auto/disable.js

@@ -1,17 +1,17 @@
-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';
-import ConfirmCommand from '../../../lib/confirmCommand.js';
 import tsheredoc from 'tsheredoc';
+import ConfirmCommand from '../../../lib/confirmCommand.js';
 const heredoc = tsheredoc.default;
 export default class Disable extends Command {
-    static topic = 'certs';
     static description = 'disable ACM for an app';
     static flags = {
-        confirm: flags.string({ char: 'c', hidden: true }),
         app: flags.app({ required: true }),
+        confirm: flags.string({ char: 'c', hidden: true }),
         remote: flags.remote(),
     };
+    static topic = 'certs';
     async run() {
         const { flags } = await this.parse(Disable);
         const { app, confirm } = flags;

package/lib/commands/certs/auto/enable.d.ts

@@ -1,12 +1,12 @@
 import { Command } from '@heroku-cli/command';
 export default class Enable extends Command {
-    static topic: string;
     static description: string;
     static flags: {
-        wait: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         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>;
+        wait: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     static notifier: (subtitle: string, message: string, success?: boolean) => void;
+    static topic: string;
     run(): Promise<void>;
 }

package/lib/commands/certs/auto/enable.js

@@ -1,18 +1,17 @@
-import { color } from '@heroku-cli/color';
+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 { getDomains, waitForDomains, printDomains, waitForCertIssuedOnDomains } from '../../../lib/domains/domains.js';
+import { getDomains, printDomains, waitForCertIssuedOnDomains, waitForDomains, } from '../../../lib/domains/domains.js';
 import notify from '../../../lib/notify.js';
 export default class Enable extends Command {
-    static topic = 'certs';
     static description = 'enable ACM status for an app';
     static flags = {
-        wait: flags.boolean({ description: 'watch ACM status and exit when complete' }),
         app: flags.app({ required: true }),
         remote: flags.remote(),
+        wait: flags.boolean({ description: 'watch ACM status and exit when complete' }),
     };
     static notifier = notify;
+    static topic = 'certs';
     async run() {
         const { flags } = await this.parse(Enable);
         const { app, wait } = flags;
@@ -20,26 +19,26 @@ export default class Enable extends Command {
         const domainsBeforeEnable = await getDomains(this.heroku, app);
         await this.heroku.post(`/apps/${app}/acm`, { body: {} });
         if (wait) {
-            ux.action.stop(`${color.yellow('starting')}.`);
+            ux.action.stop(`${color.info('starting')}.`);
             try {
                 await waitForCertIssuedOnDomains(this.heroku, app);
                 Enable.notifier('heroku certs:auto:enable', 'Certificate issued to all domains');
             }
             catch (error) {
                 Enable.notifier('heroku certs:auto:enable', 'An error occurred', false);
-                hux.styledHeader(`${color.red('Error')}: The certificate could not be issued to all domains. See status with ${color.cmd('heroku certs:auto')}.`);
+                hux.styledHeader(`${color.failure('Error')}: The certificate could not be issued to all domains. See status with ${color.code('heroku certs:auto')}.`);
                 throw error;
             }
         }
         else {
-            ux.action.stop(`${color.yellow('starting')}. See status with ${color.cmd('heroku certs:auto')} or wait until active with ${color.cmd('heroku certs:auto --wait')}`);
+            ux.action.stop(`${color.info('starting')}. See status with ${color.code('heroku certs:auto')} or wait until active with ${color.code('heroku certs:auto --wait')}`);
         }
         const domains = await waitForDomains(this.heroku, app);
         const changedCnames = domains.filter(domain => {
             const domainBeforeEnable = domainsBeforeEnable.find(domainBefore => domain.hostname === domainBefore.hostname);
             return domainBeforeEnable && domain.cname !== domainBeforeEnable.cname;
         });
-        const message = `Your certificate will now be managed by Heroku. Check the status by running ${color.cmd('heroku certs:auto')}.`;
+        const message = `Your certificate will now be managed by Heroku. Check the status by running ${color.code('heroku certs:auto')}.`;
         if (domains.length === 0 || changedCnames.length > 0) {
             printDomains(changedCnames, message);
         }