@oclif/core 3.13.1 → 3.14.0

package/lib/{config/cache.d.ts → cache.d.ts}

@@ -1,6 +1,7 @@
-import { Plugin } from '../interfaces';
+import { PJSON, Plugin } from './interfaces';
 type CacheContents = {
     rootPlugin: Plugin;
+    exitCodes: PJSON.Plugin['oclif']['exitCodes'];
 };
 type ValueOf<T> = T[keyof T];
 /**
@@ -10,5 +11,6 @@ export default class Cache extends Map<keyof CacheContents, ValueOf<CacheContent
     static instance: Cache;
     static getInstance(): Cache;
     get(key: 'rootPlugin'): Plugin | undefined;
+    get(key: 'exitCodes'): PJSON.Plugin['oclif']['exitCodes'] | undefined;
 }
 export {};

package/lib/config/config.js

@@ -32,6 +32,7 @@ const is_wsl_1 = __importDefault(require("is-wsl"));
 const node_os_1 = require("node:os");
 const node_path_1 = require("node:path");
 const node_url_1 = require("node:url");
+const cache_1 = __importDefault(require("../cache"));
 const cli_ux_1 = require("../cli-ux");
 const theme_1 = require("../cli-ux/theme");
 const errors_1 = require("../errors");
@@ -42,7 +43,6 @@ const settings_1 = require("../settings");
 const fs_1 = require("../util/fs");
 const os_1 = require("../util/os");
 const util_2 = require("../util/util");
-const cache_1 = __importDefault(require("./cache"));
 const plugin_loader_1 = __importDefault(require("./plugin-loader"));
 const ts_node_1 = require("./ts-node");
 const util_3 = require("./util");
@@ -265,7 +265,9 @@ class Config {
         this.rootPlugin = await this.pluginLoader.loadRoot();
         // Cache the root plugin so that we can reference it later when determining if
         // we should skip ts-node registration for an ESM plugin.
-        cache_1.default.getInstance().set('rootPlugin', this.rootPlugin);
+        const cache = cache_1.default.getInstance();
+        cache.set('rootPlugin', this.rootPlugin);
+        cache.set('exitCodes', this.rootPlugin.pjson.oclif.exitCodes ?? {});
         this.root = this.rootPlugin.root;
         this.pjson = this.rootPlugin.pjson;
         this.plugins.set(this.rootPlugin.name, this.rootPlugin);

package/lib/config/ts-node.js

@@ -5,11 +5,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.tsPath = exports.TS_CONFIGS = void 0;
 const node_path_1 = require("node:path");
+const cache_1 = __importDefault(require("../cache"));
 const errors_1 = require("../errors");
 const settings_1 = require("../settings");
 const fs_1 = require("../util/fs");
 const util_1 = require("../util/util");
-const cache_1 = __importDefault(require("./cache"));
 const util_2 = require("./util");
 // eslint-disable-next-line new-cap
 const debug = (0, util_2.Debug)('ts-node');

package/lib/errors/errors/cli.js

@@ -8,6 +8,7 @@ const chalk_1 = __importDefault(require("chalk"));
 const clean_stack_1 = __importDefault(require("clean-stack"));
 const indent_string_1 = __importDefault(require("indent-string"));
 const wrap_ansi_1 = __importDefault(require("wrap-ansi"));
+const cache_1 = __importDefault(require("../../cache"));
 const screen_1 = require("../../screen");
 const config_1 = require("../config");
 /**
@@ -18,7 +19,7 @@ function addOclifExitCode(error, options) {
         ;
         error.oclif = {};
     }
-    error.oclif.exit = options?.exit === undefined ? 2 : options.exit;
+    error.oclif.exit = options?.exit === undefined ? cache_1.default.getInstance().get('exitCodes')?.default ?? 2 : options.exit;
     return error;
 }
 exports.addOclifExitCode = addOclifExitCode;

package/lib/interfaces/parser.d.ts

@@ -11,6 +11,7 @@ export type CLIParseErrorOptions = {
         input?: ParserInput;
         output?: ParserOutput;
     };
+    exit?: number;
 };
 export type OutputArgs<T extends ParserInput['args']> = {
     [P in keyof T]: any;
@@ -212,6 +213,11 @@ export type OptionFlagProps = FlagProps & {
      * separate on spaces.
      */
     delimiter?: ',';
+    /**
+     * Allow input value to be read from stdin.
+     * Should only be used on one flag at a time.
+     */
+    allowStdin?: boolean;
 };
 export type FlagParserContext = Command & {
     token: FlagToken;

package/lib/interfaces/pjson.d.ts

@@ -29,6 +29,15 @@ export declare namespace PJSON {
             default?: string;
             description?: string;
             devPlugins?: string[];
+            exitCodes?: {
+                default?: number;
+                failedFlagParsing?: number;
+                failedFlagValidation?: number;
+                invalidArgsSpec?: number;
+                nonExistentFlag?: number;
+                requiredArgs?: number;
+                unexpectedArgs?: number;
+            };
             flexibleTaxonomy?: boolean;
             helpClass?: string;
             helpOptions?: HelpOptions;

package/lib/parser/errors.d.ts

@@ -1,6 +1,5 @@
 import { CLIError } from '../errors';
-import { Flag, OptionFlag } from '../interfaces';
-import { Arg, ArgInput, CLIParseErrorOptions } from '../interfaces/parser';
+import { Arg, ArgInput, CLIParseErrorOptions, OptionFlag } from '../interfaces/parser';
 export { CLIError } from '../errors';
 export type Validation = {
     name: string;
@@ -16,32 +15,26 @@ export declare class CLIParseError extends CLIError {
 }
 export declare class InvalidArgsSpecError extends CLIParseError {
     args: ArgInput;
-    constructor({ args, parse }: CLIParseErrorOptions & {
+    constructor({ args, exit, parse }: CLIParseErrorOptions & {
         args: ArgInput;
     });
 }
 export declare class RequiredArgsError extends CLIParseError {
     args: Arg<any>[];
-    constructor({ args, flagsWithMultiple, parse, }: CLIParseErrorOptions & {
+    constructor({ args, exit, flagsWithMultiple, parse, }: CLIParseErrorOptions & {
         args: Arg<any>[];
         flagsWithMultiple?: string[];
     });
 }
-export declare class RequiredFlagError extends CLIParseError {
-    flag: Flag<any>;
-    constructor({ flag, parse }: CLIParseErrorOptions & {
-        flag: Flag<any>;
-    });
-}
 export declare class UnexpectedArgsError extends CLIParseError {
     args: unknown[];
-    constructor({ args, parse }: CLIParseErrorOptions & {
+    constructor({ args, exit, parse }: CLIParseErrorOptions & {
         args: unknown[];
     });
 }
 export declare class NonExistentFlagsError extends CLIParseError {
     flags: string[];
-    constructor({ flags, parse }: CLIParseErrorOptions & {
+    constructor({ exit, flags, parse }: CLIParseErrorOptions & {
         flags: string[];
     });
 }
@@ -52,7 +45,13 @@ export declare class ArgInvalidOptionError extends CLIParseError {
     constructor(arg: Arg<any>, input: string);
 }
 export declare class FailedFlagValidationError extends CLIParseError {
-    constructor({ failed, parse }: CLIParseErrorOptions & {
+    constructor({ exit, failed, parse }: CLIParseErrorOptions & {
         failed: Validation[];
     });
 }
+export declare class FailedFlagParsingError extends CLIParseError {
+    constructor({ flag, message }: {
+        flag: string;
+        message: string;
+    });
+}

package/lib/parser/errors.js

@@ -3,40 +3,40 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FailedFlagValidationError = exports.ArgInvalidOptionError = exports.FlagInvalidOptionError = exports.NonExistentFlagsError = exports.UnexpectedArgsError = exports.RequiredFlagError = exports.RequiredArgsError = exports.InvalidArgsSpecError = exports.CLIParseError = exports.CLIError = void 0;
+exports.FailedFlagParsingError = exports.FailedFlagValidationError = exports.ArgInvalidOptionError = exports.FlagInvalidOptionError = exports.NonExistentFlagsError = exports.UnexpectedArgsError = exports.RequiredArgsError = exports.InvalidArgsSpecError = exports.CLIParseError = exports.CLIError = void 0;
 const chalk_1 = __importDefault(require("chalk"));
+const cache_1 = __importDefault(require("../cache"));
 const list_1 = require("../cli-ux/list");
 const errors_1 = require("../errors");
 const util_1 = require("../util/util");
-const help_1 = require("./help");
 var errors_2 = require("../errors");
 Object.defineProperty(exports, "CLIError", { enumerable: true, get: function () { return errors_2.CLIError; } });
 class CLIParseError extends errors_1.CLIError {
     parse;
     constructor(options) {
         options.message += '\nSee more help with --help';
-        super(options.message);
+        super(options.message, { exit: options.exit });
         this.parse = options.parse;
     }
 }
 exports.CLIParseError = CLIParseError;
 class InvalidArgsSpecError extends CLIParseError {
     args;
-    constructor({ args, parse }) {
+    constructor({ args, exit, parse }) {
         let message = 'Invalid argument spec';
         const namedArgs = Object.values(args).filter((a) => a.name);
         if (namedArgs.length > 0) {
             const list = (0, list_1.renderList)(namedArgs.map((a) => [`${a.name} (${a.required ? 'required' : 'optional'})`, a.description]));
             message += `:\n${list}`;
         }
-        super({ message, parse });
+        super({ exit: cache_1.default.getInstance().get('exitCodes')?.invalidArgsSpec ?? exit, message, parse });
         this.args = args;
     }
 }
 exports.InvalidArgsSpecError = InvalidArgsSpecError;
 class RequiredArgsError extends CLIParseError {
     args;
-    constructor({ args, flagsWithMultiple, parse, }) {
+    constructor({ args, exit, flagsWithMultiple, parse, }) {
         let message = `Missing ${args.length} required arg${args.length === 1 ? '' : 's'}`;
         const namedArgs = args.filter((a) => a.name);
         if (namedArgs.length > 0) {
@@ -48,35 +48,25 @@ class RequiredArgsError extends CLIParseError {
             message += `\n\nNote: ${flags} allow${flagsWithMultiple.length === 1 ? 's' : ''} multiple values. Because of this you need to provide all arguments before providing ${flagsWithMultiple.length === 1 ? 'that flag' : 'those flags'}.`;
             message += '\nAlternatively, you can use "--" to signify the end of the flags and the beginning of arguments.';
         }
-        super({ message, parse });
+        super({ exit: cache_1.default.getInstance().get('exitCodes')?.requiredArgs ?? exit, message, parse });
         this.args = args;
     }
 }
 exports.RequiredArgsError = RequiredArgsError;
-class RequiredFlagError extends CLIParseError {
-    flag;
-    constructor({ flag, parse }) {
-        const usage = (0, list_1.renderList)((0, help_1.flagUsages)([flag], { displayRequired: false }));
-        const message = `Missing required flag:\n${usage}`;
-        super({ message, parse });
-        this.flag = flag;
-    }
-}
-exports.RequiredFlagError = RequiredFlagError;
 class UnexpectedArgsError extends CLIParseError {
     args;
-    constructor({ args, parse }) {
+    constructor({ args, exit, parse }) {
         const message = `Unexpected argument${args.length === 1 ? '' : 's'}: ${args.join(', ')}`;
-        super({ message, parse });
+        super({ exit: cache_1.default.getInstance().get('exitCodes')?.unexpectedArgs ?? exit, message, parse });
         this.args = args;
     }
 }
 exports.UnexpectedArgsError = UnexpectedArgsError;
 class NonExistentFlagsError extends CLIParseError {
     flags;
-    constructor({ flags, parse }) {
+    constructor({ exit, flags, parse }) {
         const message = `Nonexistent flag${flags.length === 1 ? '' : 's'}: ${flags.join(', ')}`;
-        super({ message, parse });
+        super({ exit: cache_1.default.getInstance().get('exitCodes')?.nonExistentFlag ?? exit, message, parse });
         this.flags = flags;
     }
 }
@@ -96,12 +86,22 @@ class ArgInvalidOptionError extends CLIParseError {
 }
 exports.ArgInvalidOptionError = ArgInvalidOptionError;
 class FailedFlagValidationError extends CLIParseError {
-    constructor({ failed, parse }) {
+    constructor({ exit, failed, parse }) {
         const reasons = failed.map((r) => r.reason);
         const deduped = (0, util_1.uniq)(reasons);
         const errString = deduped.length === 1 ? 'error' : 'errors';
         const message = `The following ${errString} occurred:\n  ${chalk_1.default.dim(deduped.join('\n  '))}`;
-        super({ message, parse });
+        super({ exit: cache_1.default.getInstance().get('exitCodes')?.failedFlagValidation ?? exit, message, parse });
     }
 }
 exports.FailedFlagValidationError = FailedFlagValidationError;
+class FailedFlagParsingError extends CLIParseError {
+    constructor({ flag, message }) {
+        super({
+            exit: cache_1.default.getInstance().get('exitCodes')?.failedFlagParsing,
+            message: `Parsing --${flag} \n\t${message}`,
+            parse: {},
+        });
+    }
+}
+exports.FailedFlagParsingError = FailedFlagParsingError;

package/lib/parser/parse.d.ts

@@ -1,4 +1,5 @@
 import { OutputArgs, OutputFlags, ParserInput, ParserOutput } from '../interfaces/parser';
+export declare const readStdin: () => Promise<null | string>;
 export declare class Parser<T extends ParserInput, TFlags extends OutputFlags<T['flags']>, BFlags extends OutputFlags<T['flags']>, TArgs extends OutputArgs<T['args']>> {
     private readonly input;
     private readonly argv;

package/lib/parser/parse.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Parser = void 0;
+exports.Parser = exports.readStdin = void 0;
 /* eslint-disable no-await-in-loop */
 const node_readline_1 = require("node:readline");
 const util_1 = require("../util/util");
@@ -54,6 +54,7 @@ const readStdin = async () => {
         }, { once: true });
     });
 };
+exports.readStdin = readStdin;
 function isNegativeNumber(input) {
     return /^-\d/g.test(input);
 }
@@ -80,14 +81,14 @@ class Parser {
     }
     async parse() {
         this._debugInput();
-        const parseFlag = (arg) => {
+        const parseFlag = async (arg) => {
             const { isLong, name } = this.findFlag(arg);
             if (!name) {
                 const i = arg.indexOf('=');
                 if (i !== -1) {
                     const sliced = arg.slice(i + 1);
                     this.argv.unshift(sliced);
-                    const equalsParsed = parseFlag(arg.slice(0, i));
+                    const equalsParsed = await parseFlag(arg.slice(0, i));
                     if (!equalsParsed) {
                         this.argv.shift();
                     }
@@ -101,11 +102,17 @@ class Parser {
                     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);
+                let 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' || this.findFlag(input).name) {
                     throw new errors_1.CLIError(`Flag --${name} expects a value`);
                 }
+                if (flag.allowStdin && input === '-') {
+                    const stdin = await (0, exports.readStdin)();
+                    if (stdin) {
+                        input = stdin.trim();
+                    }
+                }
                 this.raw.push({ flag: flag.name, input, type: 'flag' });
             }
             else {
@@ -129,7 +136,7 @@ class Parser {
                     parsingFlags = false;
                     continue;
                 }
-                if (parseFlag(input)) {
+                if (await parseFlag(input)) {
                     continue;
                 }
                 if (input === '--') {
@@ -183,7 +190,7 @@ class Parser {
                 args[token.arg] = parsed;
             }
             else if (!arg.ignoreStdin && !stdinRead) {
-                let stdin = await readStdin();
+                let stdin = await (0, exports.readStdin)();
                 if (stdin) {
                     stdin = stdin.trim();
                     const parsed = await arg.parse(stdin, ctx, arg);
@@ -257,8 +264,7 @@ class Parser {
                 return await flag.parse(input, ctx, flag);
             }
             catch (error) {
-                error.message = `Parsing --${flag.name} \n\t${error.message}\nSee more help with --help`;
-                throw error;
+                throw new errors_1.FailedFlagParsingError({ flag: flag.name, message: error.message });
             }
         };
         /* Could add a valueFunction (if there is a value/env/default) and could metadata.

package/lib/parser/validate.js

@@ -7,12 +7,18 @@ async function validate(parse) {
     let cachedResolvedFlags;
     function validateArgs() {
         if (parse.output.nonExistentFlags?.length > 0) {
-            throw new errors_1.NonExistentFlagsError({ flags: parse.output.nonExistentFlags, parse });
+            throw new errors_1.NonExistentFlagsError({
+                flags: parse.output.nonExistentFlags,
+                parse,
+            });
         }
         const maxArgs = Object.keys(parse.input.args).length;
         if (parse.input.strict && parse.output.argv.length > maxArgs) {
             const extras = parse.output.argv.slice(maxArgs);
-            throw new errors_1.UnexpectedArgsError({ args: extras, parse });
+            throw new errors_1.UnexpectedArgsError({
+                args: extras,
+                parse,
+            });
         }
         const missingRequiredArgs = [];
         let hasOptional = false;
@@ -23,7 +29,10 @@ async function validate(parse) {
             else if (hasOptional) {
                 // (required arg) check whether an optional has occurred before
                 // optionals should follow required, not before
-                throw new errors_1.InvalidArgsSpecError({ args: parse.input.args, parse });
+                throw new errors_1.InvalidArgsSpecError({
+                    args: parse.input.args,
+                    parse,
+                });
             }
             if (arg.required && !parse.output.args[name] && parse.output.args[name] !== 0) {
                 missingRequiredArgs.push(arg);
@@ -33,7 +42,11 @@ async function validate(parse) {
             const flagsWithMultiple = Object.entries(parse.input.flags)
                 .filter(([_, flagDef]) => flagDef.type === 'option' && Boolean(flagDef.multiple))
                 .map(([name]) => name);
-            throw new errors_1.RequiredArgsError({ args: missingRequiredArgs, flagsWithMultiple, parse });
+            throw new errors_1.RequiredArgsError({
+                args: missingRequiredArgs,
+                flagsWithMultiple,
+                parse,
+            });
         }
     }
     async function validateFlags() {
@@ -57,7 +70,10 @@ async function validate(parse) {
         const results = await Promise.all(promises);
         const failed = results.filter((r) => r.status === 'failed');
         if (failed.length > 0)
-            throw new errors_1.FailedFlagValidationError({ failed, parse });
+            throw new errors_1.FailedFlagValidationError({
+                failed,
+                parse,
+            });
     }
     async function resolveFlags(flags) {
         if (cachedResolvedFlags)

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@oclif/core",
   "description": "base library for oclif CLIs",
-  "version": "3.13.1",
+  "version": "3.14.0",
   "author": "Salesforce",
   "bugs": "https://github.com/oclif/core/issues",
   "dependencies": {