@salesforce/command

constructor

constructor(config?: SfdxResult);

property data

data: AnyJson;

property tableColumnData

tableColumnData?: any;

property ux

ux: UX;

method display

display: () => void;

property args

protected args: OutputArgs;

property configAggregator

protected configAggregator: SfdxConfigAggregator;

property deprecated

protected static deprecated?: Deprecation;

property flags

static readonly flags: Interfaces.FlagInput<T>;

property flags

protected flags: OutputFlags<any>;

property flagsConfig

protected static flagsConfig: FlagsConfig;

property hubOrg

protected hubOrg?: Org;

property lifecycleEventNames

protected readonly lifecycleEventNames: string[];

• event names to be registered for command specific hooks

property logger

protected logger: Logger;

property org

protected org?: Org;

property project

protected project?: SfProject;

property requiresDevhubUsername

protected static requiresDevhubUsername: boolean;

property requiresProject

protected static requiresProject: boolean;

property requiresUsername

protected static requiresUsername: boolean;

property result

protected static result: SfdxResult;

property result

protected result: Result;

property statics

readonly statics: typeof SfdxCommand;

property supportsDevhubUsername

protected static supportsDevhubUsername: boolean;

property supportsUsername

protected static supportsUsername: boolean;

property tableColumnData

protected static tableColumnData: string[];

property usage

static readonly usage: string;

property ux

protected ux: UX;

property varargs

protected static varargs: VarargsConfig;

property varargs

protected varargs?: JsonMap;

method assignHubOrg

protected assignHubOrg: () => Promise<void>;

method assignOrg

protected assignOrg: () => Promise<void>;

method assignProject

protected assignProject: () => Promise<void>;

method catch

protected catch: (err: any) => Promise<void>;

method finally

protected finally: (err: Optional<Error>) => Promise<void>;

method formatError

protected formatError: (error: SfError) => string[];

• Format errors and actions for human consumption. Adds 'ERROR running <command name>', and outputs all errors in red. When there are actions, we add 'Try this:' in blue followed by each action in red on its own line.

  Returns

  {string[]} Returns decorated messages.

method getJsonResultObject

protected getJsonResultObject: (
    result?: AnyJson,
    status?: number
) => { status: number; result: AnyJson };

method getVarArgsConfig

static getVarArgsConfig: () => Partial<VarargsConfig> | undefined;

method init

protected init: () => Promise<void>;

method initLoggerAndUx

protected initLoggerAndUx: () => Promise<void>;

• Initialize logger and ux for the command

method parseVarargs

protected parseVarargs: (args?: string[]) => JsonMap;

method run

abstract run: () => Promise<any>;

• Actual command run code goes here.

  Returns

  {Promise} Returns a promise

  Throws

  {Error | SfError} Throws an error. If the error is not an SfError, it will be wrapped in an SfError. If the error contains exitCode field, process.exitCode will set to it.

method shouldEmitHelp

protected shouldEmitHelp: () => boolean;

method warnIfDeprecated

protected warnIfDeprecated: () => void;

constructor

constructor(logger: Logger, isOutputEnabled?: boolean, ux?: any);

• Do not directly construct instances of this class -- use UX.create instead.

property cli

cli: any;

property warnings

static warnings: Set<string>;

• Collection of warnings that can be accessed and manipulated later.

  {Set}

method confirm

confirm: (message: string) => Promise<boolean>;

• Prompt the user for confirmation.

  Parameter message

  The message displayed to the user.

  Returns

  {Promise} Returns true if the user inputs 'y' or 'yes', and false if the user inputs 'n' or 'no'.

method create

static create: () => Promise<UX>;

• Create a UX instance.

  Returns

  {Promise} A Promise of the created UX instance.

method error

error: (...args: unknown[]) => UX;

• Logs an error at ERROR level and conditionally writes to stderr if stream output is enabled.

  Parameter args

  The errors to log.

  Returns

  {UX}

method errorJson

errorJson: (obj: object) => UX;

• Logs an object as JSON at ERROR level and to stderr.

  Parameter obj

  The error object to log -- must be serializable as JSON.

  Returns

  {UX}

  Throws

  {TypeError} If the object is not JSON-serializable.

method formatDeprecationWarning

static formatDeprecationWarning: (def: DeprecationDefinition) => string;

• Formats a deprecation warning for display to stderr, stdout, and/or logs.

  Parameter def

  The definition for the deprecated object.

  Returns

  {string} The formatted deprecation message.

method getSpinnerStatus

getSpinnerStatus: () => Optional<string>;

• Get the spinner status.

  Returns

  {Optional}

method log

log: (...args: string[]) => UX;

• Logs at INFO level and conditionally writes to stdout if stream output is enabled.

  Parameter args

  The messages or objects to log.

  Returns

  {UX}

method logJson

logJson: (obj: Record<string, unknown>) => UX;

• Log JSON to stdout and to the log file with log level info.

  Parameter obj

  The object to log -- must be serializable as JSON.

  Returns

  {UX}

  Throws

  {TypeError} If the object is not JSON-serializable.

method pauseSpinner

pauseSpinner: <T>(fn: () => T, icon?: string) => Optional<T>;

• Pause the spinner and call the given function.

  Parameter fn

  The function to be called in the pause.

  Parameter icon

  The string displayed to the user.

  Returns

  {T} The result returned by the passed in function.

method prompt

prompt: (name: string, options?: IPromptOptions) => Promise<string>;

• Prompt the user for input.

  Parameter name

  The string that the user sees when prompted for information.

  Parameter options

  A prompt option configuration.

  Returns

  {Promise} The user input to the prompt.

method setSpinnerStatus

setSpinnerStatus: (status?: string) => void;

• Update the spinner status.

  Parameter status

  The message displayed to the user.

method startSpinner

startSpinner: (
    message: string,
    status?: string,
    opts?: OclifActionOptions
) => void;

• Start a spinner action after displaying the given message.

  Parameter message

  The message displayed to the user.

  Parameter status

  The status displayed to the user.

  Parameter opts

  The options to select whereas spinner will output to stderr or stdout.

method stopSpinner

stopSpinner: (message?: string) => void;

• Stop the spinner action.

  Parameter message

  The message displayed to the user.

method styledHeader

styledHeader: (header: string) => UX;

• Logs at INFO level and conditionally writes to stdout in a styled header format if stream output is enabled.

  Parameter header

  The header to be styled.

  Returns

  {UX}

method styledJSON

styledJSON: (obj: object) => UX;

• Log at INFO level and conditionally write to stdout in styled JSON format if stream output is enabled.

  Parameter obj

  The object to be styled for stdout.

  Returns

  {UX}

method styledObject

styledObject: (obj: object, keys?: string[]) => UX;

• Logs at INFO level and conditionally writes to stdout in a styled object format if stream output is enabled.

  Parameter obj

  The object to be styled for stdout.

  Parameter keys

  The object keys to be written to stdout.

  Returns

  {UX}

method table

table: (
    rows: any[],
    columns?: TableColumns,
    options?: CliUx.Table.table.Options
) => UX;

• Logs at INFO level and conditionally writes to stdout in a table format if stream output is enabled.

  Parameter rows

  The rows of data to be output in table format.

  Parameter columns

  Table column options

  Parameter options

  The SfdxTableOptions to use for formatting.

  Returns

  {UX}

method warn

warn: (message: string) => UX;

• Logs a warning as WARN level and conditionally writes to stderr if the log level is WARN or above and stream output is enabled. The message is added to the static UX.warnings set if stream output is _not_ enabled, for later consumption and manipulation.

  Parameter message

  The warning message to output.

  Returns

  {UX}

  See Also

  • UX.warnings

property data

data?: AnyJson;

property display

display?: (this: Result) => void;

property tableColumnData

tableColumnData?: TableColumns;

type Any

type Any<T> = Omit<Partial<Interfaces.Flag<T>>, 'deprecated'> & SfdxProperties;

type Array

type Array<T = string> = Option<T[]> & {
    delimiter?: string;
};

type BaseBoolean

type BaseBoolean<T> = Partial<Interfaces.BooleanFlag<T>>;

type Boolean

type Boolean<T = any> = BaseBoolean<T> & SfdxProperties;

type Bounds

type Bounds<T> = {
    min?: T;
    max?: T;
};

type Builtin

type Builtin = {
    type: 'builtin';
} & Partial<SfdxProperties>;

type DateTime

type DateTime = Option<Date>;

type Deprecatable

type Deprecatable = {
    deprecated?: Deprecation;
};

type Describable

type Describable = {
    description: string;
    longDescription?: string;
};

type Discriminant

type Discriminant = {
    kind: Kind;
};

type Discriminated

type Discriminated<T> = T & Discriminant;

type Enum

type Enum<T> = Interfaces.EnumFlagOptions<T> & SfdxProperties;

type Input

type Input<T extends Interfaces.FlagOutput> = Interfaces.FlagInput<T>;

type Kind

type Kind = keyof typeof flags;

type MappedArray

type MappedArray<T> = Omit<flags.Array<T>, 'options'> & {
    map: (val: string) => T;
    options?: T[];
};

type Milliseconds

type Milliseconds = Option<Duration> & Bounds<Duration | number>;

type Minutes

type Minutes = Option<Duration> & Bounds<Duration | number>;

type Number

type Number = Option<number> & NumericBounds;

type NumericBounds

type NumericBounds = Bounds<number>;

type Option

type Option<T = any> = Omit<Partial<CustomOptionFlag<T>>, 'deprecated'> &
    SfdxProperties &
    Validatable;

type Output

type Output = Interfaces.FlagOutput;

type Seconds

type Seconds = Option<Duration> & Bounds<Duration | number>;

type SfdxProperties

type SfdxProperties = Describable & Deprecatable;

type String

type String = Option<string>;

type Url

type Url = Option<URL>;

type Validatable

type Validatable = {
    validate?: string | RegExp | ((val: string) => boolean);
};