@oclif/core 3.0.0-beta.2 → 3.0.0-beta.21

package/lib/parser/parse.d.ts

@@ -16,4 +16,7 @@ export declare class Parser<T extends ParserInput, TFlags extends OutputFlags<T[
     private get _argTokens();
     private _setNames;
     private mapAndValidateFlags;
+    private findLongFlag;
+    private findShortFlag;
+    private findFlag;
 }

package/lib/parser/parse.js

@@ -3,43 +3,23 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Parser = void 0;
 /* eslint-disable no-await-in-loop */
 const errors_1 = require("./errors");
-const readline = require("readline");
-const util_1 = require("../util");
+const util_1 = require("../util/util");
+const node_readline_1 = require("node:readline");
 let debug;
 try {
-    // eslint-disable-next-line no-negated-condition
-    debug = process.env.CLI_FLAGS_DEBUG !== '1' ? () => { } : require('debug')('../parser');
+    debug =
+        process.env.CLI_FLAGS_DEBUG === '1'
+            ? require('debug')('../parser')
+            : () => {
+                // noop
+            };
 }
 catch {
-    debug = () => { };
+    debug = () => {
+        // noop
+    };
 }
-/**
- * Support reading from stdin in Node 14 and older.
- *
- * This generally works for Node 14 and older EXCEPT when it's being
- * run from another process, in which case it will hang indefinitely. Because
- * of that issue we updated this to use AbortController but since AbortController
- * is only available in Node 16 and newer, we have to keep this legacy version.
- *
- * See these issues for more details on the hanging indefinitely bug:
- * https://github.com/oclif/core/issues/330
- * https://github.com/oclif/core/pull/363
- *
- * @returns Promise<string | null>
- */
-const readStdinLegacy = async () => {
-    const { stdin } = process;
-    let result;
-    if (stdin.isTTY)
-        return null;
-    result = '';
-    stdin.setEncoding('utf8');
-    for await (const chunk of stdin) {
-        result += chunk;
-    }
-    return result;
-};
-const readStdinWithTimeout = async () => {
+const readStdin = async () => {
     const { stdin, stdout } = process;
     // process.stdin.isTTY is true whenever it's running in a terminal.
     // process.stdin.isTTY is undefined when it's running in a pipe, e.g. echo 'foo' | my-cli command
@@ -48,17 +28,17 @@ const readStdinWithTimeout = async () => {
     // Because of this, we have to set a timeout to prevent the process from hanging.
     if (stdin.isTTY)
         return null;
-    return new Promise(resolve => {
+    return new Promise((resolve) => {
         let result = '';
         const ac = new AbortController();
-        const signal = ac.signal;
+        const { signal } = ac;
         const timeout = setTimeout(() => ac.abort(), 100);
-        const rl = readline.createInterface({
+        const rl = (0, node_readline_1.createInterface)({
             input: stdin,
             output: stdout,
             terminal: false,
         });
-        rl.on('line', line => {
+        rl.on('line', (line) => {
             result += line;
         });
         rl.once('close', () => {
@@ -74,58 +54,34 @@ const readStdinWithTimeout = async () => {
         }, { once: true });
     });
 };
-const readStdin = async () => {
-    const { stdin, version } = process;
-    debug('stdin.isTTY', stdin.isTTY);
-    const nodeMajorVersion = Number(version.split('.')[0].replace(/^v/, ''));
-    debug('node version', nodeMajorVersion);
-    return nodeMajorVersion > 14 ? readStdinWithTimeout() : readStdinLegacy();
-};
 function isNegativeNumber(input) {
     return /^-\d/g.test(input);
 }
+const validateOptions = (flag, input) => {
+    if (flag.options && !flag.options.includes(input))
+        throw new errors_1.FlagInvalidOptionError(flag, input);
+    return input;
+};
 class Parser {
+    input;
+    argv;
+    raw = [];
+    booleanFlags;
+    flagAliases;
+    context;
+    currentFlag;
     constructor(input) {
         this.input = input;
-        this.raw = [];
         this.context = input.context ?? {};
         this.argv = [...input.argv];
         this._setNames();
-        this.booleanFlags = (0, util_1.pickBy)(input.flags, f => f.type === 'boolean');
-        this.flagAliases = Object.fromEntries(Object.values(input.flags).flatMap(flag => {
-            return (flag.aliases ?? []).map(a => [a, flag]);
-        }));
+        this.booleanFlags = (0, util_1.pickBy)(input.flags, (f) => f.type === 'boolean');
+        this.flagAliases = Object.fromEntries(Object.values(input.flags).flatMap((flag) => [...(flag.aliases ?? []), ...(flag.charAliases ?? [])].map((a) => [a, flag])));
     }
     async parse() {
         this._debugInput();
-        const findLongFlag = (arg) => {
-            const name = arg.slice(2);
-            if (this.input.flags[name]) {
-                return name;
-            }
-            if (this.flagAliases[name]) {
-                return this.flagAliases[name].name;
-            }
-            if (arg.startsWith('--no-')) {
-                const flag = this.booleanFlags[arg.slice(5)];
-                if (flag && flag.allowNo)
-                    return flag.name;
-            }
-        };
-        const findShortFlag = ([_, char]) => {
-            if (this.flagAliases[char]) {
-                return this.flagAliases[char].name;
-            }
-            return Object.keys(this.input.flags).find(k => (this.input.flags[k].char === char && char !== undefined && this.input.flags[k].char !== undefined));
-        };
-        const findFlag = (arg) => {
-            const isLong = arg.startsWith('--');
-            const short = isLong ? false : arg.startsWith('-');
-            const name = isLong ? findLongFlag(arg) : (short ? findShortFlag(arg) : undefined);
-            return { name, isLong };
-        };
         const parseFlag = (arg) => {
-            const { name, isLong } = findFlag(arg);
+            const { name, isLong } = this.findFlag(arg);
             if (!name) {
                 const i = arg.indexOf('=');
                 if (i !== -1) {
@@ -141,13 +97,16 @@ class Parser {
             }
             const flag = this.input.flags[name];
             if (flag.type === 'option') {
+                if (!flag.multiple && this.raw.some((o) => o.type === 'flag' && o.flag === name)) {
+                    throw new errors_1.CLIError(`Flag --${name} can only be specified once`);
+                }
                 this.currentFlag = flag;
                 const input = isLong || arg.length < 3 ? this.argv.shift() : arg.slice(arg[2] === '=' ? 3 : 2);
                 // if the value ends up being one of the command's flags, the user didn't provide an input
-                if ((typeof input !== 'string') || findFlag(input).name) {
+                if (typeof input !== 'string' || this.findFlag(input).name) {
                     throw new errors_1.CLIError(`Flag --${name} expects a value`);
                 }
-                this.raw.push({ type: 'flag', flag: flag.name, input: input });
+                this.raw.push({ type: 'flag', flag: flag.name, input });
             }
             else {
                 this.raw.push({ type: 'flag', flag: flag.name, input: arg });
@@ -207,11 +166,6 @@ class Parser {
         };
     }
     async _flags() {
-        const validateOptions = (flag, input) => {
-            if (flag.options && !flag.options.includes(input))
-                throw new errors_1.FlagInvalidOptionError(flag, input);
-            return input;
-        };
         const parseFlagOrThrowError = async (input, flag, context, token) => {
             if (!flag.parse)
                 return input;
@@ -236,8 +190,8 @@ class Parser {
             }
         };
         /* Could add a valueFunction (if there is a value/env/default) and could metadata.
-        *  Value function can be resolved later.
-        */
+         *  Value function can be resolved later.
+         */
         const addValueFunction = (fws) => {
             const tokenLength = fws.tokens?.length;
             // user provided some input
@@ -252,17 +206,27 @@ class Parser {
                 // multiple with custom delimiter
                 if (fws.inputFlag.flag.type === 'option' && fws.inputFlag.flag.delimiter && fws.inputFlag.flag.multiple) {
                     return {
-                        ...fws, valueFunction: async (i) => (await Promise.all(((i.tokens ?? []).flatMap(token => token.input.split(i.inputFlag.flag.delimiter)))
+                        ...fws,
+                        valueFunction: async (i) => (await Promise.all((i.tokens ?? [])
+                            .flatMap((token) => token.input.split(i.inputFlag.flag.delimiter ?? ','))
                             // trim, and remove surrounding doubleQuotes (which would hav been needed if the elements contain spaces)
-                            .map(v => v.trim().replace(/^"(.*)"$/, '$1').replace(/^'(.*)'$/, '$1'))
-                            .map(async (v) => parseFlagOrThrowError(v, i.inputFlag.flag, this.context, { ...(0, util_1.last)(i.tokens), input: v })))).map(v => validateOptions(i.inputFlag.flag, v)),
+                            .map((v) => v
+                            .trim()
+                            .replace(/^"(.*)"$/, '$1')
+                            .replace(/^'(.*)'$/, '$1'))
+                            .map(async (v) => parseFlagOrThrowError(v, i.inputFlag.flag, this.context, {
+                            ...(0, util_1.last)(i.tokens),
+                            input: v,
+                        }))))
+                            // eslint-disable-next-line unicorn/no-await-expression-member
+                            .map((v) => validateOptions(i.inputFlag.flag, v)),
                     };
                 }
                 // multiple in the oclif-core style
                 if (fws.inputFlag.flag.type === 'option' && fws.inputFlag.flag.multiple) {
                     return {
                         ...fws,
-                        valueFunction: async (i) => Promise.all((fws.tokens ?? []).map(token => parseFlagOrThrowError(validateOptions(i.inputFlag.flag, token.input), i.inputFlag.flag, this.context, token))),
+                        valueFunction: async (i) => Promise.all((fws.tokens ?? []).map((token) => parseFlagOrThrowError(validateOptions(i.inputFlag.flag, token.input), i.inputFlag.flag, this.context, token))),
                     };
                 }
                 // simple option flag
@@ -285,17 +249,19 @@ class Parser {
                 if (fws.inputFlag.flag.type === 'boolean') {
                     return {
                         ...fws,
-                        valueFunction: async (i) => Promise.resolve((0, util_1.isTruthy)(process.env[i.inputFlag.flag.env] ?? 'false')),
+                        valueFunction: async (i) => (0, util_1.isTruthy)(process.env[i.inputFlag.flag.env] ?? 'false'),
                     };
                 }
             }
             // no input, but flag has default value
+            // eslint-disable-next-line no-constant-binary-expression, valid-typeof
             if (typeof fws.inputFlag.flag.default !== undefined) {
                 return {
-                    ...fws, metadata: { setFromDefault: true },
-                    valueFunction: typeof fws.inputFlag.flag.default === 'function' ?
-                        (i, allFlags = {}) => fws.inputFlag.flag.default({ options: i.inputFlag.flag, flags: allFlags }) :
-                        async () => fws.inputFlag.flag.default,
+                    ...fws,
+                    metadata: { setFromDefault: true },
+                    valueFunction: typeof fws.inputFlag.flag.default === 'function'
+                        ? (i, allFlags = {}) => fws.inputFlag.flag.default({ options: i.inputFlag.flag, flags: allFlags })
+                        : async () => fws.inputFlag.flag.default,
                 };
             }
             // base case (no value function)
@@ -304,17 +270,19 @@ class Parser {
         const addHelpFunction = (fws) => {
             if (fws.inputFlag.flag.type === 'option' && fws.inputFlag.flag.defaultHelp) {
                 return {
-                    ...fws, helpFunction: typeof fws.inputFlag.flag.defaultHelp === 'function' ?
-                        // @ts-expect-error flag type isn't specific enough to know defaultHelp will definitely be there
-                        (i, flags, ...context) => i.inputFlag.flag.defaultHelp({ options: i.inputFlag, flags }, ...context) :
+                    ...fws,
+                    helpFunction: typeof fws.inputFlag.flag.defaultHelp === 'function'
+                        ? (i, flags, ...context) => 
                         // @ts-expect-error flag type isn't specific enough to know defaultHelp will definitely be there
-                        (i) => i.inputFlag.flag.defaultHelp,
+                        i.inputFlag.flag.defaultHelp({ options: i.inputFlag, flags }, ...context)
+                        : // @ts-expect-error flag type isn't specific enough to know defaultHelp will definitely be there
+                            (i) => i.inputFlag.flag.defaultHelp,
                 };
             }
             return fws;
         };
         const addDefaultHelp = async (fwsArray) => {
-            const valueReferenceForHelp = fwsArrayToObject(flagsWithAllValues.filter(fws => !fws.metadata?.setFromDefault));
+            const valueReferenceForHelp = fwsArrayToObject(flagsWithAllValues.filter((fws) => !fws.metadata?.setFromDefault));
             return Promise.all(fwsArray.map(async (fws) => {
                 try {
                     if (fws.helpFunction) {
@@ -333,27 +301,32 @@ class Parser {
                 return fws;
             }));
         };
-        const fwsArrayToObject = (fwsArray) => Object.fromEntries(fwsArray.filter(fws => fws.value !== undefined)
-            .map(fws => [fws.inputFlag.name, fws.value]));
+        const fwsArrayToObject = (fwsArray) => Object.fromEntries(fwsArray.filter((fws) => fws.value !== undefined).map((fws) => [fws.inputFlag.name, fws.value]));
         const flagTokenMap = this.mapAndValidateFlags();
         const flagsWithValues = await Promise.all(Object.entries(this.input.flags)
             // we check them if they have a token, or might have env, default, or defaultHelp.  Also include booleans so they get their default value
-            .filter(([name, flag]) => flag.type === 'boolean' || flag.env || flag.default !== undefined || 'defaultHelp' in flag || flagTokenMap.has(name))
+            .filter(([name, flag]) => flag.type === 'boolean' ||
+            flag.env ||
+            flag.default !== undefined ||
+            'defaultHelp' in flag ||
+            flagTokenMap.has(name))
             // match each possible flag to its token, if there is one
             .map(([name, flag]) => ({ inputFlag: { name, flag }, tokens: flagTokenMap.get(name) }))
-            .map(fws => addValueFunction(fws))
-            .filter(fws => fws.valueFunction !== undefined)
-            .map(fws => addHelpFunction(fws))
+            .map((fws) => addValueFunction(fws))
+            .filter((fws) => fws.valueFunction !== undefined)
+            .map((fws) => addHelpFunction(fws))
             // we can't apply the default values until all the other flags are resolved because `flag.default` can reference other flags
             .map(async (fws) => (fws.metadata?.setFromDefault ? fws : { ...fws, value: await fws.valueFunction?.(fws) })));
-        const valueReference = fwsArrayToObject(flagsWithValues.filter(fws => !fws.metadata?.setFromDefault));
-        const flagsWithAllValues = await Promise.all(flagsWithValues
-            .map(async (fws) => (fws.metadata?.setFromDefault ? { ...fws, value: await fws.valueFunction?.(fws, valueReference) } : fws)));
-        const finalFlags = (flagsWithAllValues.some(fws => typeof fws.helpFunction === 'function')) ? await addDefaultHelp(flagsWithAllValues) : flagsWithAllValues;
+        const valueReference = fwsArrayToObject(flagsWithValues.filter((fws) => !fws.metadata?.setFromDefault));
+        const flagsWithAllValues = await Promise.all(flagsWithValues.map(async (fws) => fws.metadata?.setFromDefault ? { ...fws, value: await fws.valueFunction?.(fws, valueReference) } : fws));
+        const finalFlags = flagsWithAllValues.some((fws) => typeof fws.helpFunction === 'function')
+            ? await addDefaultHelp(flagsWithAllValues)
+            : flagsWithAllValues;
         return {
-            // @ts-ignore original version returned an any.  Not sure how to get to the return type for `flags` prop
             flags: fwsArrayToObject(finalFlags),
-            metadata: { flags: Object.fromEntries(finalFlags.filter(fws => fws.metadata).map(fws => [fws.inputFlag.name, fws.metadata])) },
+            metadata: {
+                flags: Object.fromEntries(finalFlags.filter((fws) => fws.metadata).map((fws) => [fws.inputFlag.name, fws.metadata])),
+            },
         };
     }
     async _args() {
@@ -363,7 +336,7 @@ class Parser {
         let stdinRead = false;
         const ctx = this.context;
         for (const [name, arg] of Object.entries(this.input.args)) {
-            const token = tokens.find(t => t.arg === name);
+            const token = tokens.find((t) => t.arg === name);
             ctx.token = token;
             if (token) {
                 if (arg.options && !arg.options.includes(token.input)) {
@@ -400,7 +373,7 @@ class Parser {
                 continue;
             argv.push(token.input);
         }
-        return { argv, args: args };
+        return { argv, args };
     }
     _debugOutput(args, flags, argv) {
         if (argv.length > 0) {
@@ -422,11 +395,11 @@ class Parser {
         if (Object.keys(this.input.flags).length === 0)
             return;
         debug('available flags: %s', Object.keys(this.input.flags)
-            .map(f => `--${f}`)
+            .map((f) => `--${f}`)
             .join(' '));
     }
     get _argTokens() {
-        return this.raw.filter(o => o.type === 'arg');
+        return this.raw.filter((o) => o.type === 'arg');
     }
     _setNames() {
         for (const k of Object.keys(this.input.flags)) {
@@ -438,7 +411,7 @@ class Parser {
     }
     mapAndValidateFlags() {
         const flagTokenMap = new Map();
-        for (const token of this.raw.filter(o => o.type === 'flag')) {
+        for (const token of this.raw.filter((o) => o.type === 'flag')) {
             // fail fast if there are any invalid flags
             if (!(token.flag in this.input.flags)) {
                 throw new errors_1.CLIError(`Unexpected flag ${token.flag}`);
@@ -448,5 +421,31 @@ class Parser {
         }
         return flagTokenMap;
     }
+    findLongFlag(arg) {
+        const name = arg.slice(2);
+        if (this.input.flags[name]) {
+            return name;
+        }
+        if (this.flagAliases[name]) {
+            return this.flagAliases[name].name;
+        }
+        if (arg.startsWith('--no-')) {
+            const flag = this.booleanFlags[arg.slice(5)];
+            if (flag && flag.allowNo)
+                return flag.name;
+        }
+    }
+    findShortFlag([_, char]) {
+        if (this.flagAliases[char]) {
+            return this.flagAliases[char].name;
+        }
+        return Object.keys(this.input.flags).find((k) => this.input.flags[k].char === char && char !== undefined && this.input.flags[k].char !== undefined);
+    }
+    findFlag(arg) {
+        const isLong = arg.startsWith('--');
+        const short = isLong ? false : arg.startsWith('-');
+        const name = isLong ? this.findLongFlag(arg) : short ? this.findShortFlag(arg) : undefined;
+        return { name, isLong };
+    }
 }
 exports.Parser = Parser;

package/lib/parser/validate.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validate = void 0;
 const errors_1 = require("./errors");
-const util_1 = require("../config/util");
+const util_1 = require("../util/util");
 async function validate(parse) {
     let cachedResolvedFlags;
     function validateArgs() {
@@ -40,10 +40,10 @@ async function validate(parse) {
         const promises = Object.entries(parse.input.flags).flatMap(([name, flag]) => {
             if (parse.output.flags[name] !== undefined) {
                 return [
-                    ...flag.relationships ? validateRelationships(name, flag) : [],
-                    ...flag.dependsOn ? [validateDependsOn(name, flag.dependsOn)] : [],
-                    ...flag.exclusive ? [validateExclusive(name, flag.exclusive)] : [],
-                    ...flag.exactlyOne ? [validateExactlyOne(name, flag.exactlyOne)] : [],
+                    ...(flag.relationships ? validateRelationships(name, flag) : []),
+                    ...(flag.dependsOn ? [validateDependsOn(name, flag.dependsOn)] : []),
+                    ...(flag.exclusive ? [validateExclusive(name, flag.exclusive)] : []),
+                    ...(flag.exactlyOne ? [validateExactlyOne(name, flag.exactlyOne)] : []),
                 ];
             }
             if (flag.required) {
@@ -54,8 +54,8 @@ async function validate(parse) {
             }
             return [];
         });
-        const results = (await Promise.all(promises));
-        const failed = results.filter(r => r.status === 'failed');
+        const results = await Promise.all(promises);
+        const failed = results.filter((r) => r.status === 'failed');
         if (failed.length > 0)
             throw new errors_1.FailedFlagValidationError({ parse, failed });
     }
@@ -70,19 +70,19 @@ async function validate(parse) {
             return result ? [flag.name, parse.output.flags[flag.name]] : null;
         });
         const resolved = await Promise.all(promises);
-        cachedResolvedFlags = Object.fromEntries(resolved.filter(r => r !== null));
+        cachedResolvedFlags = Object.fromEntries(resolved.filter((r) => r !== null));
         return cachedResolvedFlags;
     }
-    const getPresentFlags = (flags) => Object.keys(flags).filter(key => key !== undefined);
+    const getPresentFlags = (flags) => Object.keys(flags).filter((key) => key !== undefined);
     function validateAcrossFlags(flag) {
         const base = { name: flag.name, validationFn: 'validateAcrossFlags' };
         const intersection = Object.entries(parse.input.flags)
-            .map(entry => entry[0]) // array of flag names
-            .filter(flagName => parse.output.flags[flagName] !== undefined) // with values
-            .filter(flagName => flag.exactlyOne && flag.exactlyOne.includes(flagName)); // and in the exactlyOne list
+            .map((entry) => entry[0]) // array of flag names
+            .filter((flagName) => parse.output.flags[flagName] !== undefined) // with values
+            .filter((flagName) => flag.exactlyOne && flag.exactlyOne.includes(flagName)); // and in the exactlyOne list
         if (intersection.length === 0) {
             // the command's exactlyOne may or may not include itself, so we'll use Set to add + de-dupe
-            const deduped = (0, util_1.uniq)(flag.exactlyOne?.map(flag => `--${flag}`) ?? []).join(', ');
+            const deduped = (0, util_1.uniq)(flag.exactlyOne?.map((flag) => `--${flag}`) ?? []).join(', ');
             const reason = `Exactly one of the following must be provided: ${deduped}`;
             return { ...base, status: 'failed', reason };
         }
@@ -100,7 +100,11 @@ async function validate(parse) {
                 continue;
             if (parse.output.flags[flag] !== undefined) {
                 const flagValue = parse.output.metadata.flags?.[flag]?.defaultHelp ?? parse.output.flags[flag];
-                return { ...base, status: 'failed', reason: `--${flag}=${flagValue} cannot also be provided when using --${name}` };
+                return {
+                    ...base,
+                    status: 'failed',
+                    reason: `--${flag}=${flagValue} cannot also be provided when using --${name}`,
+                };
             }
         }
         return { ...base, status: 'success' };
@@ -119,10 +123,16 @@ async function validate(parse) {
     async function validateDependsOn(name, flags) {
         const base = { name, validationFn: 'validateDependsOn' };
         const resolved = await resolveFlags(flags);
-        const foundAll = Object.values(resolved).every(val => val !== undefined);
+        const foundAll = Object.values(resolved).every((val) => val !== undefined);
         if (!foundAll) {
-            const formattedFlags = Object.keys(resolved).map(f => `--${f}`).join(', ');
-            return { ...base, status: 'failed', reason: `All of the following must be provided when using --${name}: ${formattedFlags}` };
+            const formattedFlags = Object.keys(resolved)
+                .map((f) => `--${f}`)
+                .join(', ');
+            return {
+                ...base,
+                status: 'failed',
+                reason: `All of the following must be provided when using --${name}: ${formattedFlags}`,
+            };
         }
         return { ...base, status: 'success' };
     }
@@ -131,24 +141,34 @@ async function validate(parse) {
         const resolved = await resolveFlags(flags);
         const foundAtLeastOne = Object.values(resolved).some(Boolean);
         if (!foundAtLeastOne) {
-            const formattedFlags = Object.keys(resolved).map(f => `--${f}`).join(', ');
-            return { ...base, status: 'failed', reason: `One of the following must be provided when using --${name}: ${formattedFlags}` };
+            const formattedFlags = Object.keys(resolved)
+                .map((f) => `--${f}`)
+                .join(', ');
+            return {
+                ...base,
+                status: 'failed',
+                reason: `One of the following must be provided when using --${name}: ${formattedFlags}`,
+            };
         }
         return { ...base, status: 'success' };
     }
     function validateRelationships(name, flag) {
-        return ((flag.relationships ?? []).map(relationship => {
+        return (flag.relationships ?? []).map((relationship) => {
             switch (relationship.type) {
-                case 'all':
+                case 'all': {
                     return validateDependsOn(name, relationship.flags);
-                case 'some':
+                }
+                case 'some': {
                     return validateSome(name, relationship.flags);
-                case 'none':
+                }
+                case 'none': {
                     return validateExclusive(name, relationship.flags);
-                default:
+                }
+                default: {
                     throw new Error(`Unknown relationship type: ${relationship.type}`);
+                }
             }
-        }));
+        });
     }
     validateArgs();
     return validateFlags();

package/lib/performance.d.ts

@@ -12,7 +12,11 @@ type PerfHighlights = {
     runTime: number;
     initTime: number;
     commandLoadTime: number;
-    pluginLoadTimes: Record<string, number>;
+    commandRunTime: number;
+    pluginLoadTimes: Record<string, {
+        duration: number;
+        details: Details;
+    }>;
     corePluginsLoadTime: number;
     userPluginsLoadTime: number;
     linkedPluginsLoadTime: number;