avo-cli 0.0.3 → 4.2.0.beta.2

data/payload/node_modules/@oclif/core/lib/parser/parse.js

@@ -0,0 +1,545 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Parser = exports.readStdin = void 0;
+/* eslint-disable no-await-in-loop */
+const node_os_1 = require("node:os");
+const node_readline_1 = require("node:readline");
+const cache_1 = __importDefault(require("../cache"));
+const logger_1 = require("../logger");
+const util_1 = require("../util/util");
+const errors_1 = require("./errors");
+let debug;
+try {
+    debug =
+        process.env.CLI_FLAGS_DEBUG === '1'
+            ? (0, logger_1.makeDebug)('parser')
+            : () => {
+                // noop
+            };
+}
+catch {
+    debug = () => {
+        // noop
+    };
+}
+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
+    // process.stdin.isTTY is undefined when it's running in a spawned process, even if there's no pipe.
+    // This means that reading from stdin could hang indefinitely while waiting for a non-existent pipe.
+    // Because of this, we have to set a timeout to prevent the process from hanging.
+    if (stdin.isTTY)
+        return null;
+    if (globalThis.oclif?.stdinCache) {
+        debug('resolved stdin from global cache', globalThis.oclif.stdinCache);
+        return globalThis.oclif.stdinCache;
+    }
+    return new Promise((resolve) => {
+        const lines = [];
+        const ac = new AbortController();
+        const { signal } = ac;
+        const timeout = setTimeout(() => ac.abort(), 10);
+        const rl = (0, node_readline_1.createInterface)({
+            input: stdin,
+            output: stdout,
+            terminal: false,
+        });
+        rl.on('line', (line) => {
+            lines.push(line);
+        });
+        rl.once('close', () => {
+            const result = lines.join(node_os_1.EOL);
+            clearTimeout(timeout);
+            debug('resolved from stdin', result);
+            globalThis.oclif = { ...globalThis.oclif, stdinCache: result };
+            resolve(result);
+        });
+        signal.addEventListener('abort', () => {
+            debug('stdin aborted');
+            clearTimeout(timeout);
+            rl.close();
+            resolve(null);
+        }, { once: true });
+    });
+};
+exports.readStdin = readStdin;
+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;
+};
+const NEGATION = '--no-';
+class Parser {
+    input;
+    argv;
+    booleanFlags;
+    context;
+    currentFlag;
+    flagAliases;
+    raw = [];
+    constructor(input) {
+        this.input = input;
+        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) => [...(flag.aliases ?? []), ...(flag.charAliases ?? [])].map((a) => [a, flag])));
+    }
+    get _argTokens() {
+        return this.raw.filter((o) => o.type === 'arg');
+    }
+    async parse() {
+        this._debugInput();
+        // eslint-disable-next-line complexity
+        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 = await parseFlag(arg.slice(0, i));
+                    if (!equalsParsed) {
+                        this.argv.shift();
+                    }
+                    return equalsParsed;
+                }
+                return false;
+            }
+            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;
+                let input = isLong || arg.length < 3 ? this.argv.shift() : arg.slice(arg[2] === '=' ? 3 : 2);
+                if (flag.allowStdin === 'only' && input !== '-' && input !== undefined && !this.findFlag(input).name) {
+                    throw new errors_1.CLIError(`Flag --${name} can only be read from stdin. The value must be "-" or not provided at all.`);
+                }
+                if ((flag.allowStdin && input === '-') || flag.allowStdin === 'only') {
+                    const stdin = await (0, exports.readStdin)();
+                    if (stdin) {
+                        input = stdin.trim();
+                    }
+                }
+                // 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) {
+                    if (flag.options) {
+                        throw new errors_1.CLIError(`Flag --${name} expects one of these values: ${flag.options.join(', ')}`);
+                    }
+                    throw new errors_1.CLIError(`Flag --${name} expects a value`);
+                }
+                this.raw.push({ flag: flag.name, input, type: 'flag' });
+            }
+            else {
+                this.raw.push({ flag: flag.name, input: arg, type: 'flag' });
+                // push the rest of the short characters back on the stack
+                if (!isLong && arg.length > 2) {
+                    this.argv.unshift(`-${arg.slice(2)}`);
+                }
+            }
+            return true;
+        };
+        let parsingFlags = true;
+        const nonExistentFlags = [];
+        let dashdash = false;
+        const originalArgv = [...this.argv];
+        while (this.argv.length > 0) {
+            const input = this.argv.shift();
+            if (parsingFlags && input.startsWith('-') && input !== '-') {
+                // attempt to parse as arg
+                if (this.input['--'] !== false && input === '--') {
+                    parsingFlags = false;
+                    continue;
+                }
+                if (await parseFlag(input)) {
+                    continue;
+                }
+                if (input === '--') {
+                    dashdash = true;
+                    continue;
+                }
+                if (this.input['--'] !== false && !isNegativeNumber(input)) {
+                    // At this point we have a value that begins with '-' or '--'
+                    // but doesn't match up to a flag definition. So we assume that
+                    // this is a misspelled flag or a non-existent flag,
+                    // e.g. --hekp instead of --help
+                    nonExistentFlags.push(input);
+                    continue;
+                }
+            }
+            if (parsingFlags && this.currentFlag && this.currentFlag.multiple && !this.currentFlag.multipleNonGreedy) {
+                this.raw.push({ flag: this.currentFlag.name, input, type: 'flag' });
+                continue;
+            }
+            // not a flag, parse as arg
+            const arg = Object.keys(this.input.args)[this._argTokens.length];
+            this.raw.push({ arg, input, type: 'arg' });
+        }
+        const [{ args, argv }, { flags, metadata }] = await Promise.all([this._args(), this._flags()]);
+        this._debugOutput(argv, args, flags);
+        const unsortedArgv = (dashdash ? [...argv, ...nonExistentFlags, '--'] : [...argv, ...nonExistentFlags]);
+        return {
+            args: args,
+            argv: unsortedArgv.sort((a, b) => originalArgv.indexOf(a) - originalArgv.indexOf(b)),
+            flags,
+            metadata,
+            nonExistentFlags,
+            raw: this.raw,
+        };
+    }
+    async _args() {
+        const argv = [];
+        const args = {};
+        const tokens = this._argTokens;
+        let stdinRead = false;
+        const ctx = this.context;
+        const parseArgInput = async (name, arg, input) => {
+            if (arg.options && !arg.options.includes(input)) {
+                throw new errors_1.ArgInvalidOptionError(arg, input);
+            }
+            ctx.token = { arg: name, input, type: 'arg' };
+            const parsed = await arg.parse(input, ctx, arg);
+            argv.push(parsed);
+            args[name] = parsed;
+        };
+        const applyDefault = async (name, arg) => {
+            if (args[name] !== undefined)
+                return;
+            if (!arg.default && arg.default !== false)
+                return;
+            const value = typeof arg.default === 'function' ? await arg.default() : arg.default;
+            if (Array.isArray(value)) {
+                for (const v of value)
+                    argv.push(v);
+            }
+            else {
+                argv.push(value);
+            }
+            args[name] = value;
+        };
+        const tryStdin = async (name, arg) => {
+            if (arg.ignoreStdin || stdinRead)
+                return;
+            let stdin = await (0, exports.readStdin)();
+            stdinRead = true;
+            if (!stdin)
+                return;
+            stdin = stdin.trim();
+            await parseArgInput(name, arg, stdin);
+        };
+        const argEntries = Object.entries(this.input.args);
+        const variadicIndex = argEntries.findIndex(([, arg]) => arg.multiple);
+        if (variadicIndex === -1) {
+            for (const [name, arg] of argEntries) {
+                const token = tokens.find((t) => t.arg === name);
+                ctx.token = token;
+                await (token ? parseArgInput(name, arg, token.input) : tryStdin(name, arg));
+                await applyDefault(name, arg);
+            }
+            // Append unmatched tokens to argv (for strict: false)
+            for (const token of tokens) {
+                if (args[token.arg] !== undefined)
+                    continue;
+                argv.push(token.input);
+            }
+        }
+        else {
+            const tokenInputs = tokens.map((t) => t.input);
+            // Consume pre-variadic args from the front
+            for (let i = 0; i < variadicIndex; i++) {
+                const [name, arg] = argEntries[i];
+                const input = tokenInputs.shift();
+                await (input === undefined ? tryStdin(name, arg) : parseArgInput(name, arg, input));
+                await applyDefault(name, arg);
+            }
+            // Consume post-variadic args from the back
+            const postVariadicParsing = [];
+            for (let i = argEntries.length - 1; i > variadicIndex; i--) {
+                const [name, arg] = argEntries[i];
+                const input = tokenInputs.pop();
+                if (input !== undefined) {
+                    postVariadicParsing.unshift({ arg, input, name });
+                }
+            }
+            // Everything remaining goes to the variadic arg
+            const [variadicName, variadicArg] = argEntries[variadicIndex];
+            if (tokenInputs.length > 0) {
+                const parsedValues = [];
+                for (const input of tokenInputs) {
+                    await parseArgInput(variadicName, variadicArg, input);
+                    parsedValues.push(args[variadicName]);
+                }
+                args[variadicName] = parsedValues;
+            }
+            for (const { arg, input, name } of postVariadicParsing) {
+                await parseArgInput(name, arg, input);
+            }
+            // Apply defaults for any args that didn't receive values
+            await applyDefault(variadicName, variadicArg);
+            for (let i = variadicIndex + 1; i < argEntries.length; i++) {
+                const [name, arg] = argEntries[i];
+                await applyDefault(name, arg);
+            }
+        }
+        return { args, argv };
+    }
+    _debugInput() {
+        debug('input: %s', this.argv.join(' '));
+        const args = Object.keys(this.input.args);
+        if (args.length > 0) {
+            debug('available args: %s', args.join(' '));
+        }
+        if (Object.keys(this.input.flags).length === 0)
+            return;
+        debug('available flags: %s', Object.keys(this.input.flags)
+            .map((f) => `--${f}`)
+            .join(' '));
+    }
+    _debugOutput(args, flags, argv) {
+        if (argv.length > 0) {
+            debug('argv: %o', argv);
+        }
+        if (Object.keys(args).length > 0) {
+            debug('args: %o', args);
+        }
+        if (Object.keys(flags).length > 0) {
+            debug('flags: %o', flags);
+        }
+    }
+    async _flags() {
+        const parseFlagOrThrowError = async (input, flag, context, token) => {
+            if (!flag.parse)
+                return input;
+            const ctx = {
+                ...context,
+                error: context?.error,
+                exit: context?.exit,
+                jsonEnabled: context?.jsonEnabled,
+                log: context?.log,
+                logToStderr: context?.logToStderr,
+                token,
+                warn: context?.warn,
+            };
+            try {
+                if (flag.type === 'boolean') {
+                    return await flag.parse(input, ctx, flag);
+                }
+                return await flag.parse(input, ctx, flag);
+            }
+            catch (error) {
+                error.message = `Parsing --${flag.name} \n\t${error.message}\nSee more help with --help`;
+                if (cache_1.default.getInstance().get('exitCodes')?.failedFlagParsing)
+                    error.oclif = { exit: cache_1.default.getInstance().get('exitCodes')?.failedFlagParsing };
+                throw error;
+            }
+        };
+        /* Could add a valueFunction (if there is a value/env/default) and could metadata.
+         *  Value function can be resolved later.
+         */
+        const addValueFunction = (fws) => {
+            const tokenLength = fws.tokens?.length;
+            // user provided some input
+            if (tokenLength) {
+                // boolean
+                if (fws.inputFlag.flag.type === 'boolean' && (0, util_1.last)(fws.tokens)?.input) {
+                    const doesNotContainNegation = (i) => {
+                        const possibleNegations = [i.inputFlag.name, ...(i.inputFlag.flag.aliases ?? [])].map((n) => `${NEGATION}${n}`);
+                        const input = (0, util_1.last)(i.tokens)?.input;
+                        if (!input)
+                            return true;
+                        return !possibleNegations.includes(input);
+                    };
+                    return {
+                        ...fws,
+                        valueFunction: async (i) => parseFlagOrThrowError(doesNotContainNegation(i), i.inputFlag.flag, this.context, (0, util_1.last)(i.tokens)),
+                    };
+                }
+                // multiple with custom delimiter
+                if (fws.inputFlag.flag.type === 'option' && fws.inputFlag.flag.delimiter && fws.inputFlag.flag.multiple) {
+                    // regex that will identify unescaped delimiters
+                    const makeDelimiter = (delimiter) => new RegExp(`(?<!\\\\)${delimiter}`);
+                    return {
+                        ...fws,
+                        valueFunction: async (i) => (await Promise.all((i.tokens ?? [])
+                            .flatMap((token) => token.input.split(makeDelimiter(i.inputFlag.flag.delimiter ?? ',')))
+                            // trim, and remove surrounding doubleQuotes (which would hav been needed if the elements contain spaces)
+                            .map((v) => v
+                            .trim()
+                            // remove escaped characters from delimiter
+                            // example: --opt="a\,b,c" -> ["a,b", "c"]
+                            .replaceAll(new RegExp(`\\\\${i.inputFlag.flag.delimiter}`, 'g'), i.inputFlag.flag.delimiter ?? ',')
+                            .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)),
+                    };
+                }
+                // 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))),
+                    };
+                }
+                // simple option flag
+                if (fws.inputFlag.flag.type === 'option') {
+                    return {
+                        ...fws,
+                        valueFunction: async (i) => parseFlagOrThrowError(validateOptions(i.inputFlag.flag, (0, util_1.last)(fws.tokens)?.input), i.inputFlag.flag, this.context, (0, util_1.last)(fws.tokens)),
+                    };
+                }
+            }
+            // no input: env flags
+            if (fws.inputFlag.flag.env && process.env[fws.inputFlag.flag.env]) {
+                const valueFromEnv = process.env[fws.inputFlag.flag.env];
+                if (fws.inputFlag.flag.type === 'option' && valueFromEnv) {
+                    return {
+                        ...fws,
+                        valueFunction: async (i) => parseFlagOrThrowError(validateOptions(i.inputFlag.flag, valueFromEnv), i.inputFlag.flag, this.context),
+                    };
+                }
+                if (fws.inputFlag.flag.type === 'boolean') {
+                    return {
+                        ...fws,
+                        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({ flags: allFlags, options: i.inputFlag.flag })
+                        : async () => fws.inputFlag.flag.default,
+                };
+            }
+            // base case (no value function)
+            return fws;
+        };
+        const addHelpFunction = (fws) => {
+            if (fws.inputFlag.flag.type === 'option' && fws.inputFlag.flag.defaultHelp) {
+                return {
+                    ...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.inputFlag.flag.defaultHelp({ flags, options: i.inputFlag }, ...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));
+            return Promise.all(fwsArray.map(async (fws) => {
+                try {
+                    if (fws.helpFunction) {
+                        return {
+                            ...fws,
+                            metadata: {
+                                ...fws.metadata,
+                                defaultHelp: await fws.helpFunction?.(fws, valueReferenceForHelp, this.context),
+                            },
+                        };
+                    }
+                }
+                catch {
+                    // no-op
+                }
+                return fws;
+            }));
+        };
+        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))
+            // match each possible flag to its token, if there is one
+            .map(([name, flag]) => ({ inputFlag: { flag, name }, tokens: flagTokenMap.get(name) }))
+            .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;
+        return {
+            flags: fwsArrayToObject(finalFlags),
+            metadata: {
+                flags: Object.fromEntries(finalFlags.filter((fws) => fws.metadata).map((fws) => [fws.inputFlag.name, fws.metadata])),
+            },
+        };
+    }
+    _setNames() {
+        for (const k of Object.keys(this.input.flags)) {
+            this.input.flags[k].name = k;
+        }
+        for (const k of Object.keys(this.input.args)) {
+            this.input.args[k].name = k;
+        }
+    }
+    findFlag(arg) {
+        const isLong = arg.startsWith('--');
+        const short = isLong ? false : arg.startsWith('-');
+        const name = isLong ? this.findLongFlag(arg) : short ? this.findShortFlag(arg) : undefined;
+        return { isLong, name };
+    }
+    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(NEGATION)) {
+            const flag = this.booleanFlags[arg.slice(NEGATION.length)];
+            if (flag && flag.allowNo)
+                return flag.name;
+            const flagAlias = this.flagAliases[arg.slice(NEGATION.length)];
+            if (flagAlias && flagAlias.type === 'boolean' && flagAlias.allowNo) {
+                return flagAlias.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);
+    }
+    mapAndValidateFlags() {
+        const flagTokenMap = new Map();
+        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}`);
+            }
+            const existing = flagTokenMap.get(token.flag) ?? [];
+            flagTokenMap.set(token.flag, [...existing, token]);
+        }
+        return flagTokenMap;
+    }
+}
+exports.Parser = Parser;

data/payload/node_modules/@oclif/core/lib/parser/validate.d.ts

@@ -0,0 +1,5 @@
+import { ParserInput, ParserOutput } from '../interfaces/parser';
+export declare function validate(parse: {
+    input: ParserInput;
+    output: ParserOutput;
+}): Promise<void>;