first commit

node_modules/@oclif/core/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Salesforce.com
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

node_modules/@oclif/core/README.md

@@ -0,0 +1,150 @@
+<img src="https://user-images.githubusercontent.com/449385/38243295-e0a47d58-372e-11e8-9bc0-8c02a6f4d2ac.png" width="260" height="73">
+
+# oclif: Node.JS Open CLI Framework
+
+[![Version](https://img.shields.io/npm/v/@oclif/core.svg)](https://npmjs.org/package/@oclif/core)
+[![Downloads/week](https://img.shields.io/npm/dw/@oclif/core.svg)](https://npmjs.org/package/@oclif/core)
+[![License](https://img.shields.io/npm/l/@oclif/core.svg)](https://github.com/oclif/core/blob/main/LICENSE)
+
+# 🗒 Description
+
+This is a framework for building CLIs in Node.js. This framework was built out of the [Salesforce CLI](https://github.com/salesforcecli/cli) but generalized to build any custom CLI. It's designed both for single-file CLIs with a few flag options (like `cat` or `ls`), or for very complex CLIs that have subcommands (like `git` or `heroku`).
+
+[See the docs for more information](http://oclif.io/docs/introduction).
+
+# 🚀 Getting Started Tutorial
+
+The [Getting Started tutorial](http://oclif.io/docs/introduction) is a step-by-step guide to introduce you to oclif. If you have not developed anything in a command line before, this tutorial is a great place to get started.
+
+# ✨ Features
+
+- **Flag/Argument parsing** - No CLI framework would be complete without a flag parser. We've built a custom one from years of experimentation that we feel consistently handles user input flexible enough for the user to be able to use the CLI in ways they expect, but without compromising strictness guarantees to the developer.
+- **Super Speed** - The overhead for running an oclif CLI command is almost nothing. [It requires very few dependencies](https://www.npmjs.com/package/@oclif/core?activeTab=dependencies) (only 28 dependencies in a minimal setup—including all transitive dependencies). Also, only the command to be executed will be required with node. So large CLIs with many commands will load equally as fast as a small one with a single command.
+- **CLI Generator** - Run a single command to scaffold out a fully functional CLI and get started quickly. See [Getting Started Tutorial](<[#-usage](https://oclif.io/docs/introduction.html)>).
+- **Testing Helpers** - We've put a lot of work into making commands easier to test and mock out stdout/stderr. The generator will automatically create [scaffolded tests](https://github.com/oclif/hello-world/blob/main/test/commands/hello.test.ts).
+- **Auto-documentation** - By default you can pass `--help` to the CLI to get help such as flag options and argument information. This information is also automatically placed in the README whenever the npm package of the CLI is published. See the [hello-world CLI example](https://github.com/oclif/hello-world)
+- **Plugins** - Using [plugins](https://oclif.io/docs/plugins), users of the CLI can extend it with new functionality, a CLI can be split into modular components, and functionality can be shared amongst multiple CLIs. See [Building your own plugin](https://oclif.io/docs/plugins#building-your-own-plugin).
+- **Hooks** - Use lifecycle hooks to run functionality any time a CLI starts, or on custom triggers. Use this whenever custom functionality needs to be shared between various components of the CLI.
+- **TypeScript** - Everything in the core of oclif is written in TypeScript and the generator will build fully configured TypeScript CLIs. If you use plugins support, the CLI will automatically use `ts-node` to run the plugins enabling you to use TypeScript with minimal-to-no boilerplate needed for any oclif CLI.
+- **Auto-updating Installers** - oclif can package your CLI into [different installers](https://oclif.io/docs/releasing) that will not require the user to already have node installed on the machine. These can be made auto-updatable by using [plugin-update](https://github.com/oclif/plugin-update).
+- **Everything is Customizable** - Pretty much anything can be swapped out and replaced inside oclif if needed—including the arg/flag parser.
+- **Autocomplete** - Automatically include autocomplete for your CLI. This includes not only command names and flag names, but flag values as well. For example, it's possible to configure the Heroku CLI to have completions for Heroku app names:
+
+```
+$ heroku info --app=<tab><tab> # will complete with all the Heroku apps a user has in their account
+```
+
+# 📌 Requirements
+
+Currently, Node 18+ is supported. We support the [LTS versions](https://nodejs.org/en/about/releases) of Node. You can add the [node](https://www.npmjs.com/package/node) package to your CLI to ensure users are running a specific version of Node.
+
+# 📌 Migrating
+
+See the [v3 migration guide](./guides/V3_MIGRATION.md) for an overview of breaking changes that occurred between v2 and v3.
+
+See the [v2 migration guide](./guides/V2_MIGRATION.md) for an overview of breaking changes that occurred between v1 and v2.
+
+Migrating from `@oclif/config` and `@oclif/command`? See the [v1 migration guide](./guides/PRE_CORE_MIGRATION.md).
+
+# 📌 Documentation
+
+The official oclif website, [oclif.io](https://oclif.io/), contains all the documentation you need for developing a CLI with oclif.
+
+If there's anything you'd like to see in the documentation, please submit an issue on the [oclif.github.io repo](https://github.com/oclif/oclif.github.io).
+
+# 🚀 Standalone Usage
+
+We strongly encourage you generate an oclif CLI using the [oclif cli](https://github.com/oclif/oclif). The generator will generate an npm package with `@oclif/core` as a dependency.
+
+You can, however, use `@oclif/core` in a standalone script like this:
+
+```typescript
+#!/usr/bin/env -S node --loader ts-node/esm --no-warnings=ExperimentalWarning
+
+import * as fs from 'fs'
+import {Command, Flags, flush, handle} from '@oclif/core'
+
+class LS extends Command {
+  static description = 'List the files in a directory.'
+  static flags = {
+    version: Flags.version(),
+    help: Flags.help(),
+    dir: Flags.string({
+      char: 'd',
+      default: process.cwd(),
+    }),
+  }
+
+  async run() {
+    const {flags} = await this.parse(LS)
+    const files = fs.readdirSync(flags.dir)
+    for (const f of files) {
+      this.log(f)
+    }
+  }
+}
+
+LS.run(process.argv.slice(2), {
+  root: import.meta.dirname,
+  // Tell oclif what the contents of the package.json are.
+  // You could also set these in your package.json but specifying
+  // them here is useful if you're attempting to bundle your CLI
+  // without a package.json
+  pjson: {
+    name: 'ls',
+    version: '0.0.1',
+    oclif: {
+      // Tell oclif that this is a single command CLI
+      // See: https://oclif.io/docs/command_discovery_strategies
+      commands: {
+        strategy: 'single',
+        target: 'index.js',
+      },
+    },
+  },
+}).then(
+  async () => {
+    await flush()
+  },
+  async (err) => {
+    await handle(err)
+  },
+)
+```
+
+Then run it like this:
+
+```sh-session
+$ ts-node myscript.ts
+...files in current dir...
+```
+
+You can also use oclif's `Parser` separately:
+
+```javascript
+// index.js
+import {Args, Flags, Parser} from '@oclif/core'
+
+const {args, flags} = await Parser.parse(process.argv.slice(2), {
+  args: {
+    name: Args.string({required: true}),
+  },
+  flags: {
+    from: Flags.string({char: 'f', default: 'oclif'}),
+  },
+})
+
+console.log(`hello ${args.name} from ${flags.from}`)
+```
+
+```
+$ node index.js world --from oclif
+
+hello world from oclif
+```
+
+**NOTE** If you're using the `Parser` class, you will not be able to use the builtin `help` and `version` flags since those require the context of an oclif project.
+
+🚀 Contributing
+
+See the [contributing guide](./CONTRIBUTING.md).

node_modules/@oclif/core/lib/args.d.ts

@@ -0,0 +1,38 @@
+import { URL } from 'node:url';
+import { Arg, ArgDefinition } from './interfaces/parser';
+/**
+ * Create a custom arg.
+ *
+ * @example
+ * type Id = string
+ * type IdOpts = { startsWith: string; length: number };
+ *
+ * export const myArg = custom<Id, IdOpts>({
+ *   parse: async (input, opts) => {
+ *     if (input.startsWith(opts.startsWith) && input.length === opts.length) {
+ *       return input
+ *     }
+ *
+ *     throw new Error('Invalid id')
+ *   },
+ * })
+ */
+export declare function custom<T = string, P = Record<string, unknown>>(_defaults: Partial<Arg<T, P>>): ArgDefinition<T, P>;
+export declare const boolean: ArgDefinition<boolean, Record<string, unknown>>;
+export declare const integer: ArgDefinition<number, {
+    max?: number;
+    min?: number;
+}>;
+export declare const directory: ArgDefinition<string, {
+    exists?: boolean;
+}>;
+export declare const file: ArgDefinition<string, {
+    exists?: boolean;
+}>;
+/**
+ * Initializes a string as a URL. Throws an error
+ * if the string is not a valid URL.
+ */
+export declare const url: ArgDefinition<URL, Record<string, unknown>>;
+declare const stringArg: ArgDefinition<string, Record<string, unknown>>;
+export { stringArg as string };

node_modules/@oclif/core/lib/args.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.string = exports.url = exports.file = exports.directory = exports.integer = exports.boolean = void 0;
+exports.custom = custom;
+const node_url_1 = require("node:url");
+const fs_1 = require("./util/fs");
+const util_1 = require("./util/util");
+function custom(defaults) {
+    return (options = {}) => ({
+        parse: async (i, _context, _opts) => i,
+        ...defaults,
+        ...options,
+        input: [],
+        type: 'option',
+    });
+}
+exports.boolean = custom({
+    parse: async (b) => Boolean(b) && (0, util_1.isNotFalsy)(b),
+});
+exports.integer = custom({
+    async parse(input, _, opts) {
+        if (!/^-?\d+$/.test(input))
+            throw new Error(`Expected an integer but received: ${input}`);
+        const num = Number.parseInt(input, 10);
+        if (opts.min !== undefined && num < opts.min)
+            throw new Error(`Expected an integer greater than or equal to ${opts.min} but received: ${input}`);
+        if (opts.max !== undefined && num > opts.max)
+            throw new Error(`Expected an integer less than or equal to ${opts.max} but received: ${input}`);
+        return num;
+    },
+});
+exports.directory = custom({
+    async parse(input, _, opts) {
+        if (opts.exists)
+            return (0, fs_1.dirExists)(input);
+        return input;
+    },
+});
+exports.file = custom({
+    async parse(input, _, opts) {
+        if (opts.exists)
+            return (0, fs_1.fileExists)(input);
+        return input;
+    },
+});
+/**
+ * Initializes a string as a URL. Throws an error
+ * if the string is not a valid URL.
+ */
+exports.url = custom({
+    async parse(input) {
+        try {
+            return new node_url_1.URL(input);
+        }
+        catch {
+            throw new Error(`Expected a valid url but received: ${input}`);
+        }
+    },
+});
+const stringArg = custom({});
+exports.string = stringArg;

node_modules/@oclif/core/lib/cache.d.ts

@@ -0,0 +1,27 @@
+import { Config } from './config/config';
+import { OclifConfiguration, Plugin } from './interfaces';
+type CacheContents = {
+    rootPlugin: Plugin;
+    config: Config;
+    exitCodes: OclifConfiguration['exitCodes'];
+    '@oclif/core': OclifCoreInfo;
+};
+type OclifCoreInfo = {
+    name: string;
+    version: string;
+};
+type ValueOf<T> = T[keyof T];
+/**
+ * A simple cache for storing values that need to be accessed globally.
+ */
+export default class Cache extends Map<keyof CacheContents, ValueOf<CacheContents>> {
+    static instance: Cache;
+    constructor();
+    static getInstance(): Cache;
+    get(_key: 'config'): Config | undefined;
+    get(_key: '@oclif/core'): OclifCoreInfo;
+    get(_key: 'rootPlugin'): Plugin | undefined;
+    get(_key: 'exitCodes'): OclifConfiguration['exitCodes'] | undefined;
+    private getOclifCoreMeta;
+}
+export {};

node_modules/@oclif/core/lib/cache.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+/**
+ * A simple cache for storing values that need to be accessed globally.
+ */
+class Cache extends Map {
+    static instance;
+    constructor() {
+        super();
+        this.set('@oclif/core', this.getOclifCoreMeta());
+    }
+    static getInstance() {
+        if (!Cache.instance) {
+            Cache.instance = new Cache();
+        }
+        return Cache.instance;
+    }
+    get(key) {
+        return super.get(key);
+    }
+    getOclifCoreMeta() {
+        try {
+            return { name: '@oclif/core', version: require('@oclif/core/package.json').version };
+        }
+        catch {
+            try {
+                return {
+                    name: '@oclif/core',
+                    version: JSON.parse((0, node_fs_1.readFileSync)((0, node_path_1.join)(__dirname, '..', 'package.json'), 'utf8')).version,
+                };
+            }
+            catch {
+                return { name: '@oclif/core', version: 'unknown' };
+            }
+        }
+    }
+}
+exports.default = Cache;

node_modules/@oclif/core/lib/command.d.ts

@@ -0,0 +1,191 @@
+import { Config } from './config';
+import { PrettyPrintableError } from './errors';
+import { LoadOptions } from './interfaces/config';
+import { CommandError } from './interfaces/errors';
+import { ArgInput, ArgOutput, ArgProps, BooleanFlagProps, Deprecation, FlagInput, FlagOutput, Arg as IArg, Flag as IFlag, Input, OptionFlagProps, ParserOutput } from './interfaces/parser';
+import { Plugin } from './interfaces/plugin';
+/**
+ * An abstract class which acts as the base for each command
+ * in your project.
+ */
+export declare abstract class Command {
+    argv: string[];
+    config: Config;
+    private static readonly _base;
+    /** An array of aliases for this command. */
+    static aliases: string[];
+    /** An order-dependent object of arguments for the command */
+    static args: ArgInput;
+    static baseFlags: FlagInput;
+    /**
+     * Emit deprecation warning when a command alias is used
+     */
+    static deprecateAliases?: boolean;
+    static deprecationOptions?: Deprecation;
+    /**
+     * A full description of how to use the command.
+     *
+     * If no summary, the first line of the description will be used as the summary.
+     */
+    static description: string | undefined;
+    static enableJsonFlag: boolean;
+    /**
+     * An array of examples to show at the end of the command's help.
+     *
+     * IF only a string is provided, it will try to look for a line that starts
+     * with the cmd.bin as the example command and the rest as the description.
+     * If found, the command will be formatted appropriately.
+     *
+     * ```
+     * EXAMPLES:
+     *   A description of a particular use case.
+     *
+     *     $ <%= config.bin => command flags
+     * ```
+     */
+    static examples: Command.Example[];
+    /** A hash of flags for the command */
+    static flags: FlagInput;
+    static hasDynamicHelp: boolean;
+    static help: string | undefined;
+    /** Hide the command from help */
+    static hidden: boolean;
+    /** An array of aliases for this command that are hidden from help. */
+    static hiddenAliases: string[];
+    /** A command ID, used mostly in error or verbose reporting. */
+    static id: string;
+    static plugin: Plugin | undefined;
+    static readonly pluginAlias?: string;
+    static readonly pluginName?: string;
+    static readonly pluginType?: string;
+    /** Mark the command as a given state (e.g. beta or deprecated) in help */
+    static state?: 'beta' | 'deprecated' | string;
+    /** When set to false, allows a variable amount of arguments */
+    static strict: boolean;
+    /**
+     * The tweet-sized description for your class, used in a parent-commands
+     * sub-command listing and as the header for the command help.
+     */
+    static summary?: string;
+    /**
+     * An override string (or strings) for the default usage documentation.
+     */
+    static usage: string | string[] | undefined;
+    protected debug: (...args: any[]) => void;
+    id: string | undefined;
+    parsed: boolean;
+    constructor(argv: string[], config: Config);
+    /**
+     * instantiate and run the command
+     *
+     * @param {Command.Class} this - the command class
+     * @param {string[]} argv argv
+     * @param {LoadOptions} opts options
+     * @returns {Promise<unknown>} result
+     */
+    static run<T extends Command>(this: new (argv: string[], config: Config) => T, argv?: string[], opts?: LoadOptions): Promise<ReturnType<T['run']>>;
+    protected get ctor(): typeof Command;
+    protected _run<T>(): Promise<T>;
+    protected catch(err: CommandError): Promise<any>;
+    error(input: Error | string, options: {
+        code?: string;
+        exit: false;
+    } & PrettyPrintableError): void;
+    error(input: Error | string, options?: {
+        code?: string;
+        exit?: number;
+    } & PrettyPrintableError): never;
+    exit(code?: number): never;
+    protected finally(_: Error | undefined): Promise<any>;
+    protected init(): Promise<any>;
+    /**
+     * Determine if the command is being run with the --json flag in a command that supports it.
+     *
+     * @returns {boolean} true if the command supports json and the --json flag is present
+     */
+    jsonEnabled(): boolean;
+    log(message?: string, ...args: any[]): void;
+    protected logJson(json: unknown): void;
+    logToStderr(message?: string, ...args: any[]): void;
+    protected parse<F extends FlagOutput, B extends FlagOutput, A extends ArgOutput>(options?: Input<F, B, A>, argv?: string[]): Promise<ParserOutput<F, B, A>>;
+    /**
+     * actual command run code goes here
+     */
+    abstract run(): Promise<any>;
+    protected toErrorJson(err: unknown): any;
+    protected toSuccessJson(result: unknown): any;
+    warn(input: Error | string): Error | string;
+    protected warnIfCommandDeprecated(): void;
+    protected warnIfFlagDeprecated(flags: Record<string, unknown>): void;
+    private removeEnvVar;
+}
+export declare namespace Command {
+    /**
+     * The Command class exported by a command file.
+     */
+    type Class = typeof Command & {
+        id: string;
+        run(argv?: string[], config?: LoadOptions): Promise<any>;
+    };
+    /**
+     * A cached command that's had a `load` method attached to it.
+     *
+     * The `Plugin` class loads the commands from the manifest (if it exists) or requires and caches
+     * the commands directly from the commands directory inside the plugin. At this point the plugin
+     * is working with `Command.Cached`. It then appends a `load` method to each one. If the a command
+     * is executed then the `load` method is used to require the command class.
+     */
+    type Loadable = Cached & {
+        load(): Promise<Command.Class>;
+    };
+    /**
+     * A cached version of the command. This is created by the cachedCommand utility and
+     * stored in the oclif.manifest.json.
+     */
+    type Cached = {
+        [key: string]: unknown;
+        aliasPermutations?: string[] | undefined;
+        aliases: string[];
+        args: {
+            [name: string]: Arg.Cached;
+        };
+        deprecateAliases?: boolean | undefined;
+        deprecationOptions?: Deprecation | undefined;
+        description?: string | undefined;
+        examples?: Example[] | undefined;
+        flags: {
+            [name: string]: Flag.Cached;
+        };
+        hasDynamicHelp?: boolean;
+        hidden: boolean;
+        hiddenAliases: string[];
+        id: string;
+        isESM?: boolean | undefined;
+        permutations?: string[] | undefined;
+        pluginAlias?: string | undefined;
+        pluginName?: string | undefined;
+        pluginType?: string | undefined;
+        relativePath?: string[] | undefined;
+        state?: 'beta' | 'deprecated' | string | undefined;
+        strict?: boolean | undefined;
+        summary?: string | undefined;
+        type?: string | undefined;
+        usage?: string | string[] | undefined;
+    };
+    type Flag = IFlag<any>;
+    namespace Flag {
+        type Cached = Omit<Flag, 'input' | 'parse'> & (BooleanFlagProps | OptionFlagProps) & {
+            hasDynamicHelp?: boolean | undefined;
+        };
+        type Any = Cached | Flag;
+    }
+    type Arg = IArg<any>;
+    namespace Arg {
+        type Cached = Omit<Arg, 'input' | 'parse'> & ArgProps;
+        type Any = Arg | Cached;
+    }
+    type Example = {
+        command: string;
+        description: string;
+    } | string;
+}

node_modules/@oclif/core/lib/command.js

@@ -0,0 +1,343 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Command = void 0;
+const node_url_1 = require("node:url");
+const node_util_1 = require("node:util");
+const cache_1 = __importDefault(require("./cache"));
+const config_1 = require("./config");
+const Errors = __importStar(require("./errors"));
+const util_1 = require("./help/util");
+const logger_1 = require("./logger");
+const Parser = __importStar(require("./parser"));
+const aggregate_flags_1 = require("./util/aggregate-flags");
+const ids_1 = require("./util/ids");
+const util_2 = require("./util/util");
+const ux_1 = require("./ux");
+const pjson = cache_1.default.getInstance().get('@oclif/core');
+/**
+ * swallows stdout epipe errors
+ * this occurs when stdout closes such as when piping to head
+ */
+process.stdout.on('error', (err) => {
+    if (err && err.code === 'EPIPE')
+        return;
+    throw err;
+});
+/**
+ * An abstract class which acts as the base for each command
+ * in your project.
+ */
+class Command {
+    argv;
+    config;
+    static _base = `${pjson.name}@${pjson.version}`;
+    /** An array of aliases for this command. */
+    static aliases = [];
+    /** An order-dependent object of arguments for the command */
+    static args = {};
+    static baseFlags;
+    /**
+     * Emit deprecation warning when a command alias is used
+     */
+    static deprecateAliases;
+    static deprecationOptions;
+    /**
+     * A full description of how to use the command.
+     *
+     * If no summary, the first line of the description will be used as the summary.
+     */
+    static description;
+    static enableJsonFlag = false;
+    /**
+     * An array of examples to show at the end of the command's help.
+     *
+     * IF only a string is provided, it will try to look for a line that starts
+     * with the cmd.bin as the example command and the rest as the description.
+     * If found, the command will be formatted appropriately.
+     *
+     * ```
+     * EXAMPLES:
+     *   A description of a particular use case.
+     *
+     *     $ <%= config.bin => command flags
+     * ```
+     */
+    static examples;
+    /** A hash of flags for the command */
+    static flags;
+    static hasDynamicHelp = false;
+    static help;
+    /** Hide the command from help */
+    static hidden;
+    /** An array of aliases for this command that are hidden from help. */
+    static hiddenAliases = [];
+    /** A command ID, used mostly in error or verbose reporting. */
+    static id;
+    static plugin;
+    static pluginAlias;
+    static pluginName;
+    static pluginType;
+    /** Mark the command as a given state (e.g. beta or deprecated) in help */
+    static state;
+    /** When set to false, allows a variable amount of arguments */
+    static strict = true;
+    /**
+     * The tweet-sized description for your class, used in a parent-commands
+     * sub-command listing and as the header for the command help.
+     */
+    static summary;
+    /**
+     * An override string (or strings) for the default usage documentation.
+     */
+    static usage;
+    debug;
+    id;
+    parsed = false;
+    constructor(argv, config) {
+        this.argv = argv;
+        this.config = config;
+        this.id = this.ctor.id;
+        try {
+            this.debug = (0, logger_1.makeDebug)(this.id ? `${this.config.bin}:${this.id}` : this.config.bin);
+        }
+        catch {
+            this.debug = () => {
+                // noop
+            };
+        }
+    }
+    /**
+     * instantiate and run the command
+     *
+     * @param {Command.Class} this - the command class
+     * @param {string[]} argv argv
+     * @param {LoadOptions} opts options
+     * @returns {Promise<unknown>} result
+     */
+    static async run(argv, opts) {
+        if (!argv)
+            argv = process.argv.slice(2);
+        // Handle the case when a file URL string is passed in such as 'import.meta.url'; covert to file path.
+        if (typeof opts === 'string' && opts.startsWith('file://')) {
+            opts = (0, node_url_1.fileURLToPath)(opts);
+        }
+        const config = await config_1.Config.load(opts || require.main?.filename || __dirname);
+        const cache = cache_1.default.getInstance();
+        if (!cache.has('config'))
+            cache.set('config', config);
+        const cmd = new this(argv, config);
+        if (!cmd.id) {
+            const id = cmd.constructor.name.toLowerCase();
+            cmd.id = id;
+            cmd.ctor.id = id;
+        }
+        return cmd._run();
+    }
+    get ctor() {
+        return this.constructor;
+    }
+    async _run() {
+        let err;
+        let result;
+        try {
+            // remove redirected env var to allow subsessions to run autoupdated client
+            this.removeEnvVar('REDIRECTED');
+            await this.init();
+            result = await this.run();
+        }
+        catch (error) {
+            err = error;
+            await this.catch(error);
+        }
+        finally {
+            await this.finally(err);
+        }
+        if (result && this.jsonEnabled())
+            this.logJson(this.toSuccessJson(result));
+        if (!this.parsed && !(0, util_2.isProd)()) {
+            process.emitWarning(`Command ${this.id} did not parse its arguments. Did you forget to call 'this.parse'?`, {
+                code: 'UnparsedCommand',
+            });
+        }
+        return result;
+    }
+    async catch(err) {
+        process.exitCode = process.exitCode ?? err.exitCode ?? 1;
+        if (this.jsonEnabled()) {
+            this.logJson(this.toErrorJson(err));
+        }
+        else {
+            if (!err.message)
+                throw err;
+            try {
+                ux_1.ux.action.stop(ux_1.ux.colorize('bold', ux_1.ux.colorize('red', '!')));
+            }
+            catch { }
+            throw err;
+        }
+    }
+    error(input, options = {}) {
+        return Errors.error(input, options);
+    }
+    exit(code = 0) {
+        Errors.exit(code);
+    }
+    async finally(_) { }
+    async init() {
+        this.debug('init version: %s argv: %o', this.ctor._base, this.argv);
+        const g = globalThis;
+        g['http-call'] = g['http-call'] || {};
+        g['http-call'].userAgent = this.config.userAgent;
+        this.warnIfCommandDeprecated();
+    }
+    /**
+     * Determine if the command is being run with the --json flag in a command that supports it.
+     *
+     * @returns {boolean} true if the command supports json and the --json flag is present
+     */
+    jsonEnabled() {
+        // If the command doesn't support json, return false
+        if (!this.ctor?.enableJsonFlag)
+            return false;
+        // If the CONTENT_TYPE env var is set to json, return true
+        if (this.config.scopedEnvVar?.('CONTENT_TYPE')?.toLowerCase() === 'json')
+            return true;
+        const passThroughIndex = this.argv.indexOf('--');
+        const jsonIndex = this.argv.indexOf('--json');
+        return passThroughIndex === -1
+            ? // If '--' is not present, then check for `--json` in this.argv
+                jsonIndex !== -1
+            : // If '--' is present, return true only the --json flag exists and is before the '--'
+                jsonIndex !== -1 && jsonIndex < passThroughIndex;
+    }
+    log(message = '', ...args) {
+        if (!this.jsonEnabled()) {
+            message = typeof message === 'string' ? message : (0, node_util_1.inspect)(message);
+            ux_1.ux.stdout(message, ...args);
+        }
+    }
+    logJson(json) {
+        ux_1.ux.stdout(ux_1.ux.colorizeJson(json, { pretty: true, theme: this.config.theme?.json }));
+    }
+    logToStderr(message = '', ...args) {
+        if (!this.jsonEnabled()) {
+            message = typeof message === 'string' ? message : (0, node_util_1.inspect)(message);
+            ux_1.ux.stderr(message, ...args);
+        }
+    }
+    async parse(options, argv = this.argv) {
+        if (!options)
+            options = this.ctor;
+        const opts = {
+            context: this,
+            ...options,
+            flags: (0, aggregate_flags_1.aggregateFlags)(options.flags, options.baseFlags, options.enableJsonFlag),
+        };
+        const hookResult = await this.config.runHook('preparse', { argv: [...argv], options: opts });
+        // Since config.runHook will only run the hook for the root plugin, hookResult.successes will always have a length of 0 or 1
+        // But to be extra safe, we find the result that matches the root plugin.
+        const argvToParse = hookResult.successes?.length
+            ? (hookResult.successes.find((s) => s.plugin.root === cache_1.default.getInstance().get('rootPlugin')?.root)?.result ??
+                argv)
+            : argv;
+        this.argv = [...argvToParse];
+        const results = await Parser.parse(argvToParse, opts);
+        this.warnIfFlagDeprecated(results.flags ?? {});
+        this.parsed = true;
+        return results;
+    }
+    toErrorJson(err) {
+        return { error: err };
+    }
+    toSuccessJson(result) {
+        return result;
+    }
+    warn(input) {
+        if (!this.jsonEnabled())
+            Errors.warn(input);
+        return input;
+    }
+    warnIfCommandDeprecated() {
+        const [id] = (0, util_1.normalizeArgv)(this.config);
+        if (this.ctor.deprecateAliases && this.ctor.aliases.includes(id)) {
+            const cmdName = (0, ids_1.toConfiguredId)(this.ctor.id, this.config);
+            const aliasName = (0, ids_1.toConfiguredId)(id, this.config);
+            this.warn((0, util_1.formatCommandDeprecationWarning)(aliasName, { to: cmdName }));
+        }
+        if (this.ctor.state === 'deprecated') {
+            const cmdName = (0, ids_1.toConfiguredId)(this.ctor.id, this.config);
+            this.warn((0, util_1.formatCommandDeprecationWarning)(cmdName, this.ctor.deprecationOptions));
+        }
+    }
+    warnIfFlagDeprecated(flags) {
+        const allFlags = (0, aggregate_flags_1.aggregateFlags)(this.ctor.flags, this.ctor.baseFlags, this.ctor.enableJsonFlag);
+        for (const flag of Object.keys(flags)) {
+            const flagDef = allFlags[flag];
+            const deprecated = flagDef?.deprecated;
+            if (deprecated) {
+                this.warn((0, util_1.formatFlagDeprecationWarning)(flag, deprecated));
+            }
+            const deprecateAliases = flagDef?.deprecateAliases;
+            if (deprecateAliases) {
+                const aliases = (0, util_2.uniq)([...(flagDef?.aliases ?? []), ...(flagDef?.charAliases ?? [])]).map((a) => a.length === 1 ? `-${a}` : `--${a}`);
+                if (aliases.length === 0)
+                    return;
+                const foundAliases = aliases.filter((alias) => this.argv.includes(alias));
+                for (const alias of foundAliases) {
+                    let preferredUsage = `--${flagDef?.name}`;
+                    if (flagDef?.char) {
+                        preferredUsage += ` | -${flagDef?.char}`;
+                    }
+                    this.warn((0, util_1.formatFlagDeprecationWarning)(alias, { to: preferredUsage }));
+                }
+            }
+        }
+    }
+    removeEnvVar(envVar) {
+        const keys = [];
+        try {
+            keys.push(...this.config.scopedEnvVarKeys(envVar));
+        }
+        catch {
+            keys.push(this.config.scopedEnvVarKey(envVar));
+        }
+        keys.map((key) => delete process.env[key]);
+    }
+}
+exports.Command = Command;

node_modules/@oclif/core/lib/config/config.d.ts

@@ -0,0 +1,136 @@
+import { Command } from '../command';
+import { Hook, Hooks, OclifConfiguration, PJSON, S3Templates, Topic, UserPJSON } from '../interfaces';
+import { ArchTypes, Config as IConfig, LoadOptions, PlatformTypes, VersionDetails } from '../interfaces/config';
+import { Plugin as IPlugin, Options } from '../interfaces/plugin';
+import { Theme } from '../interfaces/theme';
+export declare class Config implements IConfig {
+    options: Options;
+    arch: ArchTypes;
+    bin: string;
+    binAliases?: string[] | undefined;
+    binPath?: string | undefined;
+    cacheDir: string;
+    channel: string;
+    configDir: string;
+    dataDir: string;
+    dirname: string;
+    flexibleTaxonomy: boolean;
+    home: string;
+    isSingleCommandCLI: boolean;
+    name: string;
+    npmRegistry?: string | undefined;
+    nsisCustomization?: string | undefined;
+    pjson: PJSON;
+    platform: PlatformTypes;
+    plugins: Map<string, IPlugin>;
+    root: string;
+    shell: string;
+    theme?: Theme | undefined;
+    topicSeparator: ' ' | ':';
+    updateConfig: NonNullable<OclifConfiguration['update']>;
+    userAgent: string;
+    userPJSON?: UserPJSON | undefined;
+    valid: boolean;
+    version: string;
+    protected warned: boolean;
+    windows: boolean;
+    private _base;
+    private _commandIDs;
+    private _commands;
+    private _topics;
+    private commandPermutations;
+    private pluginLoader;
+    private rootPlugin;
+    private topicPermutations;
+    constructor(options: Options);
+    static load(opts?: LoadOptions): Promise<Config>;
+    get commandIDs(): string[];
+    get commands(): Command.Loadable[];
+    protected get isProd(): boolean;
+    static get rootPlugin(): IPlugin | undefined;
+    get topics(): Topic[];
+    get versionDetails(): VersionDetails;
+    protected _shell(): string;
+    protected dir(category: 'cache' | 'config' | 'data'): string;
+    findCommand(id: string, opts: {
+        must: true;
+    }): Command.Loadable;
+    findCommand(id: string, opts?: {
+        must: boolean;
+    }): Command.Loadable | undefined;
+    /**
+     * Find all command ids that include the provided command id.
+     *
+     * For example, if the command ids are:
+     * - foo:bar:baz
+     * - one:two:three
+     *
+     * `bar` would return `foo:bar:baz`
+     *
+     * @param partialCmdId string
+     * @param argv string[] process.argv containing the flags and arguments provided by the user
+     * @returns string[]
+     */
+    findMatches(partialCmdId: string, argv: string[]): Command.Loadable[];
+    findTopic(id: string, opts: {
+        must: true;
+    }): Topic;
+    findTopic(id: string, opts?: {
+        must: boolean;
+    }): Topic | undefined;
+    /**
+     * Returns an array of all command ids. If flexible taxonomy is enabled then all permutations will be appended to the array.
+     * @returns string[]
+     */
+    getAllCommandIDs(): string[];
+    /**
+     * Returns an array of all commands. If flexible taxonomy is enabled then all permutations will be appended to the array.
+     * @returns Command.Loadable[]
+     */
+    getAllCommands(): Command.Loadable[];
+    getPluginsList(): IPlugin[];
+    load(): Promise<void>;
+    loadPluginsAndCommands(opts?: {
+        force: boolean;
+    }): Promise<void>;
+    loadTheme(): Promise<Theme | undefined>;
+    protected macosCacheDir(): string | undefined;
+    runCommand<T = unknown>(id: string, argv?: string[], cachedCommand?: Command.Loadable | null): Promise<T>;
+    runHook<T extends keyof Hooks, P extends Hooks = Hooks>(event: T, opts: P[T]['options'], timeout?: number, captureErrors?: boolean): Promise<Hook.Result<P[T]['return']>>;
+    s3Key(type: keyof S3Templates, ext?: '.tar.gz' | '.tar.xz' | IConfig.s3Key.Options, options?: IConfig.s3Key.Options): string;
+    s3Url(key: string): string;
+    scopedEnvVar(k: string): string | undefined;
+    /**
+     * this DOES NOT account for bin aliases, use scopedEnvVarKeys instead which will account for bin aliases
+     * @param k {string}, the unscoped key you want to get the value for
+     * @returns {string} returns the env var key
+     */
+    scopedEnvVarKey(k: string): string;
+    /**
+     * gets the scoped env var keys for a given key, including bin aliases
+     * @param k {string}, the env key e.g. 'debug'
+     * @returns {string[]} e.g. ['SF_DEBUG', 'SFDX_DEBUG']
+     */
+    scopedEnvVarKeys(k: string): string[];
+    scopedEnvVarTrue(k: string): boolean;
+    protected windowsHome(): string | undefined;
+    protected windowsHomedriveHome(): string | undefined;
+    protected windowsUserprofileHome(): string | undefined;
+    private buildS3Config;
+    private getCmdLookupId;
+    private getTopicLookupId;
+    /**
+     * Insert legacy plugins
+     *
+     * Replace invalid CLI plugins (cli-engine plugins, mostly Heroku) loaded via `this.loadPlugins`
+     * with oclif-compatible ones returned by @oclif/plugin-legacy init hook.
+     *
+     * @param plugins array of oclif-compatible plugins
+     */
+    private insertLegacyPlugins;
+    private isJitPluginCommand;
+    private loadCommands;
+    private loadTopics;
+    private maybeAdjustDebugSetting;
+    private warn;
+}

node_modules/@oclif/core/lib/config/config.js

@@ -0,0 +1,816 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Config = void 0;
+const ejs = __importStar(require("ejs"));
+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 errors_1 = require("../errors");
+const util_1 = require("../help/util");
+const logger_1 = require("../logger");
+const module_loader_1 = require("../module-loader");
+const performance_1 = require("../performance");
+const settings_1 = require("../settings");
+const determine_priority_1 = require("../util/determine-priority");
+const fs_1 = require("../util/fs");
+const ids_1 = require("../util/ids");
+const os_1 = require("../util/os");
+const util_2 = require("../util/util");
+const ux_1 = require("../ux");
+const theme_1 = require("../ux/theme");
+const plugin_loader_1 = __importDefault(require("./plugin-loader"));
+const ts_path_1 = require("./ts-path");
+const util_3 = require("./util");
+const debug = (0, util_3.makeDebug)();
+const _pjson = cache_1.default.getInstance().get('@oclif/core');
+const BASE = `${_pjson.name}@${_pjson.version}`;
+const ROOT_ONLY_HOOKS = new Set(['preparse']);
+function displayWarnings() {
+    if (process.listenerCount('warning') > 1)
+        return;
+    process.on('warning', (warning) => {
+        console.error(warning.stack);
+        if (warning.detail)
+            console.error(warning.detail);
+    });
+}
+function channelFromVersion(version) {
+    const m = version.match(/[^-]+(?:-([^.]+))?/);
+    return (m && m[1]) || 'stable';
+}
+function isConfig(o) {
+    return o && Boolean(o._base);
+}
+class Permutations extends Map {
+    validPermutations = new Map();
+    add(permutation, commandId) {
+        this.validPermutations.set(permutation, commandId);
+        for (const id of (0, util_3.collectUsableIds)([permutation])) {
+            if (this.has(id)) {
+                this.set(id, this.get(id).add(commandId));
+            }
+            else {
+                this.set(id, new Set([commandId]));
+            }
+        }
+    }
+    get(key) {
+        return super.get(key) ?? new Set();
+    }
+    getAllValid() {
+        return [...this.validPermutations.keys()];
+    }
+    getValid(key) {
+        return this.validPermutations.get(key);
+    }
+    hasValid(key) {
+        return this.validPermutations.has(key);
+    }
+}
+class Config {
+    options;
+    arch;
+    bin;
+    binAliases;
+    binPath;
+    cacheDir;
+    channel;
+    configDir;
+    dataDir;
+    dirname;
+    flexibleTaxonomy;
+    home;
+    isSingleCommandCLI = false;
+    name;
+    npmRegistry;
+    nsisCustomization;
+    pjson;
+    platform;
+    plugins = new Map();
+    root;
+    shell;
+    theme;
+    topicSeparator = ':';
+    updateConfig;
+    userAgent;
+    userPJSON;
+    valid;
+    version;
+    warned = false;
+    windows;
+    _base = BASE;
+    _commandIDs;
+    _commands = new Map();
+    _topics = new Map();
+    commandPermutations = new Permutations();
+    pluginLoader;
+    rootPlugin;
+    topicPermutations = new Permutations();
+    constructor(options) {
+        this.options = options;
+    }
+    static async load(opts = module.filename || __dirname) {
+        (0, logger_1.setLogger)(opts);
+        // Handle the case when a file URL string is passed in such as 'import.meta.url'; covert to file path.
+        if (typeof opts === 'string' && opts.startsWith('file://')) {
+            opts = (0, node_url_1.fileURLToPath)(opts);
+        }
+        if (typeof opts === 'string')
+            opts = { root: opts };
+        if (isConfig(opts)) {
+            /**
+             * Reload the Config based on the version required by the command.
+             * This is needed because the command is given the Config instantiated
+             * by the root plugin, which may be a different version than the one
+             * required by the command.
+             *
+             * Doing this ensures that the command can freely use any method on Config that
+             * exists in the version of Config required by the command but may not exist on the
+             * root's instance of Config.
+             */
+            if (BASE !== opts._base) {
+                debug(`reloading config from ${opts._base} to ${BASE}`);
+                const config = new Config({ ...opts.options, plugins: opts.plugins });
+                await config.load();
+                return config;
+            }
+            return opts;
+        }
+        const config = new Config(opts);
+        await config.load();
+        return config;
+    }
+    get commandIDs() {
+        if (this._commandIDs)
+            return this._commandIDs;
+        this._commandIDs = this.commands.map((c) => c.id);
+        return this._commandIDs;
+    }
+    get commands() {
+        return [...this._commands.values()];
+    }
+    get isProd() {
+        return (0, util_2.isProd)();
+    }
+    static get rootPlugin() {
+        return this.rootPlugin;
+    }
+    get topics() {
+        return [...this._topics.values()];
+    }
+    get versionDetails() {
+        const [cliVersion, architecture, nodeVersion] = this.userAgent.split(' ');
+        return {
+            architecture,
+            cliVersion,
+            nodeVersion,
+            osVersion: `${(0, node_os_1.type)()} ${(0, node_os_1.release)()}`,
+            pluginVersions: Object.fromEntries([...this.plugins.values()].map((p) => [p.name, { root: p.root, type: p.type, version: p.version }])),
+            rootPath: this.root,
+            shell: this.shell,
+        };
+    }
+    _shell() {
+        let shellPath;
+        const { COMSPEC } = process.env;
+        const SHELL = process.env.SHELL ?? (0, node_os_1.userInfo)().shell?.split(node_path_1.sep)?.pop();
+        if (SHELL) {
+            shellPath = SHELL.split('/');
+        }
+        else if (this.windows && process.title.toLowerCase().includes('powershell')) {
+            shellPath = ['powershell'];
+        }
+        else if (this.windows && process.title.toLowerCase().includes('command prompt')) {
+            shellPath = ['cmd.exe'];
+        }
+        else if (this.windows && COMSPEC) {
+            shellPath = COMSPEC.split(/\\|\//);
+        }
+        else {
+            shellPath = ['unknown'];
+        }
+        return shellPath.at(-1) ?? 'unknown';
+    }
+    dir(category) {
+        const base = process.env[`XDG_${category.toUpperCase()}_HOME`] ||
+            (this.windows && process.env.LOCALAPPDATA) ||
+            (0, node_path_1.join)(this.home, category === 'data' ? '.local/share' : '.' + category);
+        return (0, node_path_1.join)(base, this.dirname);
+    }
+    findCommand(id, opts = {}) {
+        const lookupId = this.getCmdLookupId(id);
+        const command = this._commands.get(lookupId);
+        if (opts.must && !command)
+            (0, errors_1.error)(`command ${lookupId} not found`);
+        return command;
+    }
+    /**
+     * Find all command ids that include the provided command id.
+     *
+     * For example, if the command ids are:
+     * - foo:bar:baz
+     * - one:two:three
+     *
+     * `bar` would return `foo:bar:baz`
+     *
+     * @param partialCmdId string
+     * @param argv string[] process.argv containing the flags and arguments provided by the user
+     * @returns string[]
+     */
+    findMatches(partialCmdId, argv) {
+        const flags = argv
+            .filter((arg) => !(0, util_1.getHelpFlagAdditions)(this).includes(arg) && arg.startsWith('-'))
+            .map((a) => a.replaceAll('-', ''));
+        const possibleMatches = [...this.commandPermutations.get(partialCmdId)].map((k) => this._commands.get(k));
+        const matches = possibleMatches.filter((command) => {
+            const cmdFlags = Object.entries(command.flags).flatMap(([flag, def]) => def.char ? [def.char, flag] : [flag]);
+            // A command is a match if the provided flags belong to the full command
+            return flags.every((f) => cmdFlags.includes(f));
+        });
+        return matches;
+    }
+    findTopic(name, opts = {}) {
+        const lookupId = this.getTopicLookupId(name);
+        const topic = this._topics.get(lookupId);
+        if (topic)
+            return topic;
+        if (opts.must)
+            throw new Error(`topic ${name} not found`);
+    }
+    /**
+     * Returns an array of all command ids. If flexible taxonomy is enabled then all permutations will be appended to the array.
+     * @returns string[]
+     */
+    getAllCommandIDs() {
+        return this.getAllCommands().map((c) => c.id);
+    }
+    /**
+     * Returns an array of all commands. If flexible taxonomy is enabled then all permutations will be appended to the array.
+     * @returns Command.Loadable[]
+     */
+    getAllCommands() {
+        const commands = [...this._commands.values()];
+        const validPermutations = [...this.commandPermutations.getAllValid()];
+        for (const permutation of validPermutations) {
+            if (!this._commands.has(permutation)) {
+                const cmd = this._commands.get(this.getCmdLookupId(permutation));
+                commands.push({ ...cmd, id: permutation });
+            }
+        }
+        return commands;
+    }
+    getPluginsList() {
+        return [...this.plugins.values()];
+    }
+    // eslint-disable-next-line complexity
+    async load() {
+        settings_1.settings.performanceEnabled =
+            (settings_1.settings.performanceEnabled === undefined ? this.options.enablePerf : settings_1.settings.performanceEnabled) ?? false;
+        if (settings_1.settings.debug)
+            displayWarnings();
+        (0, logger_1.setLogger)(this.options);
+        const marker = performance_1.Performance.mark(performance_1.OCLIF_MARKER_OWNER, 'config.load');
+        this.pluginLoader = new plugin_loader_1.default({ plugins: this.options.plugins, root: this.options.root });
+        this.rootPlugin = await this.pluginLoader.loadRoot({ pjson: this.options.pjson });
+        // Cache the root plugin so that we can reference it later when determining if
+        // we should skip ts-node registration for an ESM plugin.
+        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);
+        this.root = this.rootPlugin.root;
+        this.pjson = this.rootPlugin.pjson;
+        this.name = this.pjson.name;
+        this.version = this.options.version || this.pjson.version || '0.0.0';
+        this.channel = this.options.channel || channelFromVersion(this.version);
+        this.valid = this.rootPlugin.valid;
+        this.arch = (0, node_os_1.arch)() === 'ia32' ? 'x86' : (0, node_os_1.arch)();
+        this.platform = is_wsl_1.default ? 'wsl' : (0, os_1.getPlatform)();
+        this.windows = this.platform === 'win32';
+        this.bin = this.pjson.oclif.bin || this.name;
+        this.binAliases = this.pjson.oclif.binAliases;
+        this.nsisCustomization = this.pjson.oclif.nsisCustomization;
+        this.dirname = this.pjson.oclif.dirname || this.name;
+        this.flexibleTaxonomy = this.pjson.oclif.flexibleTaxonomy || false;
+        // currently, only colons or spaces are valid separators
+        if (this.pjson.oclif.topicSeparator && [' ', ':'].includes(this.pjson.oclif.topicSeparator))
+            this.topicSeparator = this.pjson.oclif.topicSeparator;
+        if (this.platform === 'win32')
+            this.dirname = this.dirname.replace('/', '\\');
+        this.userAgent = `${this.name}/${this.version} ${this.platform}-${this.arch} node-${process.version}`;
+        this.shell = this._shell();
+        this.home = process.env.HOME || (this.windows && this.windowsHome()) || (0, os_1.getHomeDir)() || (0, node_os_1.tmpdir)();
+        this.cacheDir = this.scopedEnvVar('CACHE_DIR') || this.macosCacheDir() || this.dir('cache');
+        this.configDir = this.scopedEnvVar('CONFIG_DIR') || this.dir('config');
+        this.dataDir = this.scopedEnvVar('DATA_DIR') || this.dir('data');
+        this.binPath = this.scopedEnvVar('BINPATH');
+        this.npmRegistry = this.scopedEnvVar('NPM_REGISTRY') || this.pjson.oclif.npmRegistry;
+        this.theme = await this.loadTheme();
+        this.updateConfig = {
+            ...this.pjson.oclif.update,
+            node: this.pjson.oclif.update?.node ?? {},
+            s3: this.buildS3Config(),
+        };
+        this.isSingleCommandCLI = Boolean(typeof this.pjson.oclif.commands !== 'string' &&
+            this.pjson.oclif.commands?.strategy === 'single' &&
+            this.pjson.oclif.commands?.target);
+        this.maybeAdjustDebugSetting();
+        await this.loadPluginsAndCommands();
+        debug('config done');
+        marker?.addDetails({
+            commandPermutations: this.commands.length,
+            commands: [...this.plugins.values()].reduce((acc, p) => acc + p.commands.length, 0),
+            plugins: this.plugins.size,
+            topics: this.topics.length,
+        });
+        marker?.stop();
+    }
+    async loadPluginsAndCommands(opts) {
+        const pluginsMarker = performance_1.Performance.mark(performance_1.OCLIF_MARKER_OWNER, 'config.loadAllPlugins');
+        const { errors, plugins } = await this.pluginLoader.loadChildren({
+            dataDir: this.dataDir,
+            devPlugins: this.options.devPlugins,
+            force: opts?.force ?? false,
+            pluginAdditions: this.options.pluginAdditions,
+            rootPlugin: this.rootPlugin,
+            userPlugins: this.options.userPlugins,
+        });
+        this.plugins = plugins;
+        pluginsMarker?.stop();
+        const commandsMarker = performance_1.Performance.mark(performance_1.OCLIF_MARKER_OWNER, 'config.loadAllCommands');
+        for (const plugin of this.plugins.values()) {
+            this.loadCommands(plugin);
+            this.loadTopics(plugin);
+        }
+        commandsMarker?.stop();
+        for (const error of errors) {
+            this.warn(error);
+        }
+    }
+    async loadTheme() {
+        if (this.scopedEnvVarTrue('DISABLE_THEME'))
+            return;
+        const userThemeFile = (0, node_path_1.resolve)(this.configDir, 'theme.json');
+        const getDefaultTheme = async () => {
+            if (!this.pjson.oclif.theme)
+                return;
+            if (typeof this.pjson.oclif.theme === 'string') {
+                return (0, fs_1.safeReadJson)((0, node_path_1.resolve)(this.root, this.pjson.oclif.theme));
+            }
+            return this.pjson.oclif.theme;
+        };
+        const [defaultTheme, userTheme] = await Promise.all([
+            getDefaultTheme(),
+            (0, fs_1.safeReadJson)(userThemeFile),
+        ]);
+        // Merge the default theme with the user theme, giving the user theme precedence.
+        const merged = { ...defaultTheme, ...userTheme };
+        return Object.keys(merged).length > 0 ? (0, theme_1.parseTheme)(merged) : undefined;
+    }
+    macosCacheDir() {
+        return (this.platform === 'darwin' && (0, node_path_1.join)(this.home, 'Library', 'Caches', this.dirname)) || undefined;
+    }
+    async runCommand(id, argv = [], cachedCommand = null) {
+        const marker = performance_1.Performance.mark(performance_1.OCLIF_MARKER_OWNER, `config.runCommand#${id}`);
+        debug('runCommand %s %o', id, argv);
+        let c = cachedCommand ?? this.findCommand(id);
+        if (!c) {
+            const matches = this.flexibleTaxonomy ? this.findMatches(id, argv) : [];
+            const hookResult = this.flexibleTaxonomy && matches.length > 0
+                ? await this.runHook('command_incomplete', { argv, id, matches })
+                : await this.runHook('command_not_found', { argv, id });
+            if (hookResult.successes[0])
+                return hookResult.successes[0].result;
+            if (hookResult.failures[0])
+                throw hookResult.failures[0].error;
+            throw new errors_1.CLIError(`command ${id} not found`);
+        }
+        if (this.isJitPluginCommand(c)) {
+            const pluginName = c.pluginName;
+            const pluginVersion = this.pjson.oclif.jitPlugins[pluginName];
+            const jitResult = await this.runHook('jit_plugin_not_installed', {
+                argv,
+                command: c,
+                id,
+                pluginName,
+                pluginVersion,
+            });
+            if (jitResult.failures[0])
+                throw jitResult.failures[0].error;
+            if (jitResult.successes[0]) {
+                await this.loadPluginsAndCommands({ force: true });
+                c = this.findCommand(id) ?? c;
+            }
+            else {
+                // this means that no jit_plugin_not_installed hook exists, so we should run the default behavior
+                const result = await this.runHook('command_not_found', { argv, id });
+                if (result.successes[0])
+                    return result.successes[0].result;
+                if (result.failures[0])
+                    throw result.failures[0].error;
+                throw new errors_1.CLIError(`command ${id} not found`);
+            }
+        }
+        const command = await c.load();
+        await this.runHook('prerun', { argv, Command: command });
+        const result = (await command.run(argv, this));
+        // If plugins:uninstall was run, we need to remove all the uninstalled plugins
+        // from this.plugins so that the postrun hook doesn't attempt to run any
+        // hooks that might have existed in the uninstalled plugins.
+        if (c.id === 'plugins:uninstall') {
+            for (const arg of argv)
+                this.plugins.delete(arg);
+        }
+        await this.runHook('postrun', { argv, Command: command, result });
+        marker?.addDetails({ command: id, plugin: c.pluginName });
+        marker?.stop();
+        return result;
+    }
+    async runHook(event, opts, timeout, captureErrors) {
+        const marker = performance_1.Performance.mark(performance_1.OCLIF_MARKER_OWNER, `config.runHook#${event}`);
+        debug('start %s hook', event);
+        const search = (m) => {
+            if (typeof m === 'function')
+                return m;
+            if (m.default && typeof m.default === 'function')
+                return m.default;
+            return Object.values(m).find((m) => typeof m === 'function');
+        };
+        const withTimeout = async (ms, promise) => {
+            let id;
+            const timeout = new Promise((_, reject) => {
+                id = setTimeout(() => {
+                    reject(new Error(`Timed out after ${ms} ms.`));
+                }, ms).unref();
+            });
+            return Promise.race([promise, timeout]).then((result) => {
+                clearTimeout(id);
+                return result;
+            });
+        };
+        const final = {
+            failures: [],
+            successes: [],
+        };
+        const plugins = ROOT_ONLY_HOOKS.has(event) ? [this.rootPlugin] : [...this.plugins.values()];
+        const promises = plugins.map(async (p) => {
+            const debug = (0, logger_1.makeDebug)([p.name, 'hooks', event].join(':'));
+            const context = {
+                config: this,
+                debug,
+                error(message, options = {}) {
+                    (0, errors_1.error)(message, options);
+                },
+                exit(code = 0) {
+                    (0, errors_1.exit)(code);
+                },
+                log(message, ...args) {
+                    ux_1.ux.stdout(message, ...args);
+                },
+                warn(message) {
+                    (0, errors_1.warn)(message);
+                },
+            };
+            const hooks = p.hooks[event] || [];
+            for (const hook of hooks) {
+                const marker = performance_1.Performance.mark(performance_1.OCLIF_MARKER_OWNER, `config.runHook#${p.name}(${hook.target})`);
+                try {
+                    /* eslint-disable no-await-in-loop */
+                    const { filePath, isESM, module } = await (0, module_loader_1.loadWithData)(p, await (0, ts_path_1.tsPath)(p.root, hook.target, p));
+                    debug('start', isESM ? '(import)' : '(require)', filePath);
+                    // If no hook is found using the identifier, then we should `search` for the hook but only if the hook identifier is 'default'
+                    // A named identifier (e.g. MY_HOOK) that isn't found indicates that the hook isn't implemented in the plugin.
+                    const hookFn = module[hook.identifier] ?? (hook.identifier === 'default' ? search(module) : undefined);
+                    if (!hookFn) {
+                        debug('No hook found for hook definition:', hook);
+                        continue;
+                    }
+                    const result = timeout
+                        ? await withTimeout(timeout, hookFn.call(context, { ...opts, config: this, context }))
+                        : await hookFn.call(context, { ...opts, config: this, context });
+                    final.successes.push({ plugin: p, result });
+                    if (p.name === '@oclif/plugin-legacy' && event === 'init') {
+                        this.insertLegacyPlugins(result);
+                    }
+                    debug('done');
+                }
+                catch (error) {
+                    final.failures.push({ error: error, plugin: p });
+                    debug(error);
+                    // Do not throw the error if
+                    // captureErrors is set to true
+                    // error.oclif.exit is undefined or 0
+                    // error.code is MODULE_NOT_FOUND
+                    if (!captureErrors &&
+                        error.oclif?.exit !== undefined &&
+                        error.oclif?.exit !== 0 &&
+                        error.code !== 'MODULE_NOT_FOUND')
+                        throw error;
+                }
+                marker?.addDetails({
+                    event,
+                    hook: hook.target,
+                    plugin: p.name,
+                });
+                marker?.stop();
+            }
+        });
+        await Promise.all(promises);
+        debug('%s hook done', event);
+        marker?.stop();
+        return final;
+    }
+    s3Key(type, ext, options = {}) {
+        if (typeof ext === 'object')
+            options = ext;
+        else if (ext)
+            options.ext = ext;
+        const template = this.updateConfig.s3?.templates?.[options.platform ? 'target' : 'vanilla'][type] ?? '';
+        return ejs.render(template, { ...this, ...options });
+    }
+    s3Url(key) {
+        const { host } = this.updateConfig.s3 ?? { host: undefined };
+        if (!host)
+            throw new Error('no s3 host is set');
+        const url = new node_url_1.URL(host);
+        url.pathname = (0, node_path_1.join)(url.pathname, key);
+        return url.toString();
+    }
+    scopedEnvVar(k) {
+        return process.env[this.scopedEnvVarKeys(k).find((k) => process.env[k])];
+    }
+    /**
+     * this DOES NOT account for bin aliases, use scopedEnvVarKeys instead which will account for bin aliases
+     * @param k {string}, the unscoped key you want to get the value for
+     * @returns {string} returns the env var key
+     */
+    scopedEnvVarKey(k) {
+        return [this.bin, k]
+            .map((p) => p.replaceAll('@', '').replaceAll(/[/-]/g, '_'))
+            .join('_')
+            .toUpperCase();
+    }
+    /**
+     * gets the scoped env var keys for a given key, including bin aliases
+     * @param k {string}, the env key e.g. 'debug'
+     * @returns {string[]} e.g. ['SF_DEBUG', 'SFDX_DEBUG']
+     */
+    scopedEnvVarKeys(k) {
+        return [this.bin, ...(this.binAliases ?? [])]
+            .filter(Boolean)
+            .map((alias) => [alias.replaceAll('@', '').replaceAll(/[/-]/g, '_'), k].join('_').toUpperCase());
+    }
+    scopedEnvVarTrue(k) {
+        const v = this.scopedEnvVar(k);
+        return v === '1' || v === 'true';
+    }
+    windowsHome() {
+        return this.windowsHomedriveHome() || this.windowsUserprofileHome();
+    }
+    windowsHomedriveHome() {
+        return process.env.HOMEDRIVE && process.env.HOMEPATH && (0, node_path_1.join)(process.env.HOMEDRIVE, process.env.HOMEPATH);
+    }
+    windowsUserprofileHome() {
+        return process.env.USERPROFILE;
+    }
+    buildS3Config() {
+        const s3 = this.pjson.oclif.update?.s3;
+        const bucket = this.scopedEnvVar('S3_BUCKET') ?? s3?.bucket;
+        const host = s3?.host ?? (bucket && `https://${bucket}.s3.amazonaws.com`);
+        const templates = {
+            ...s3?.templates,
+            target: {
+                baseDir: '<%- bin %>',
+                manifest: "<%- channel === 'stable' ? '' : 'channels/' + channel + '/' %><%- platform %>-<%- arch %>",
+                unversioned: "<%- channel === 'stable' ? '' : 'channels/' + channel + '/' %><%- bin %>-<%- platform %>-<%- arch %><%- ext %>",
+                versioned: "<%- channel === 'stable' ? '' : 'channels/' + channel + '/' %><%- bin %>-v<%- version %>/<%- bin %>-v<%- version %>-<%- platform %>-<%- arch %><%- ext %>",
+                ...(s3?.templates && s3?.templates.target),
+            },
+            vanilla: {
+                baseDir: '<%- bin %>',
+                manifest: "<%- channel === 'stable' ? '' : 'channels/' + channel + '/' %>version",
+                unversioned: "<%- channel === 'stable' ? '' : 'channels/' + channel + '/' %><%- bin %><%- ext %>",
+                versioned: "<%- channel === 'stable' ? '' : 'channels/' + channel + '/' %><%- bin %>-v<%- version %>/<%- bin %>-v<%- version %><%- ext %>",
+                ...(s3?.templates && s3?.templates.vanilla),
+            },
+        };
+        return {
+            bucket,
+            host,
+            templates,
+        };
+    }
+    getCmdLookupId(id) {
+        if (this._commands.has(id))
+            return id;
+        if (this.commandPermutations.hasValid(id))
+            return this.commandPermutations.getValid(id);
+        return id;
+    }
+    getTopicLookupId(id) {
+        if (this._topics.has(id))
+            return id;
+        if (this.topicPermutations.hasValid(id))
+            return this.topicPermutations.getValid(id);
+        return id;
+    }
+    /**
+     * Insert legacy plugins
+     *
+     * Replace invalid CLI plugins (cli-engine plugins, mostly Heroku) loaded via `this.loadPlugins`
+     * with oclif-compatible ones returned by @oclif/plugin-legacy init hook.
+     *
+     * @param plugins array of oclif-compatible plugins
+     */
+    insertLegacyPlugins(plugins) {
+        for (const plugin of plugins) {
+            this.plugins.set(plugin.name, plugin);
+            // Delete all commands from the legacy plugin so that we can re-add them.
+            // This is necessary because determinePriority will pick the initial
+            // command that was added, which won't have been converted by PluginLegacy yet.
+            for (const cmd of plugin.commands ?? []) {
+                this._commands.delete(cmd.id);
+                for (const alias of [...(cmd.aliases ?? []), ...(cmd.hiddenAliases ?? [])]) {
+                    this._commands.delete(alias);
+                }
+            }
+            this.loadCommands(plugin);
+        }
+    }
+    isJitPluginCommand(c) {
+        // Return true if the command's plugin is listed under oclif.jitPlugins AND if the plugin hasn't been loaded to this.plugins
+        return (Object.keys(this.pjson.oclif.jitPlugins ?? {}).includes(c.pluginName ?? '') &&
+            Boolean(c?.pluginName && !this.plugins.has(c.pluginName)));
+    }
+    loadCommands(plugin) {
+        const marker = performance_1.Performance.mark(performance_1.OCLIF_MARKER_OWNER, `config.loadCommands#${plugin.name}`, { plugin: plugin.name });
+        for (const command of plugin.commands) {
+            // set canonical command id
+            if (this._commands.has(command.id)) {
+                const prioritizedCommand = (0, determine_priority_1.determinePriority)(this.pjson.oclif.plugins ?? [], [
+                    this._commands.get(command.id),
+                    command,
+                ]);
+                this._commands.set(prioritizedCommand.id, prioritizedCommand);
+            }
+            else {
+                this._commands.set(command.id, command);
+            }
+            // v3 moved command id permutations to the manifest, but some plugins may not have
+            // the new manifest yet. For those, we need to calculate the permutations here.
+            const permutations = this.flexibleTaxonomy && command.permutations === undefined
+                ? (0, util_3.getCommandIdPermutations)(command.id)
+                : (command.permutations ?? [command.id]);
+            // set every permutation
+            for (const permutation of permutations) {
+                this.commandPermutations.add(permutation, command.id);
+            }
+            const handleAlias = (alias, hidden = false) => {
+                const aliasWithDefaultTopicSeparator = (0, ids_1.toStandardizedId)(alias, this);
+                if (this._commands.has(aliasWithDefaultTopicSeparator)) {
+                    const prioritizedCommand = (0, determine_priority_1.determinePriority)(this.pjson.oclif.plugins ?? [], [
+                        this._commands.get(aliasWithDefaultTopicSeparator),
+                        command,
+                    ]);
+                    this._commands.set(aliasWithDefaultTopicSeparator, {
+                        ...prioritizedCommand,
+                        id: aliasWithDefaultTopicSeparator,
+                    });
+                }
+                else {
+                    this._commands.set(aliasWithDefaultTopicSeparator, { ...command, hidden, id: aliasWithDefaultTopicSeparator });
+                }
+                // set every permutation of the aliases
+                // v3 moved command alias permutations to the manifest, but some plugins may not have
+                // the new manifest yet. For those, we need to calculate the permutations here.
+                const aliasPermutations = this.flexibleTaxonomy && command.aliasPermutations === undefined
+                    ? (0, util_3.getCommandIdPermutations)(aliasWithDefaultTopicSeparator)
+                    : (command.permutations ?? [aliasWithDefaultTopicSeparator]);
+                // set every permutation
+                for (const permutation of aliasPermutations) {
+                    this.commandPermutations.add(permutation, command.id);
+                }
+            };
+            // set command aliases
+            for (const alias of command.aliases ?? []) {
+                handleAlias(alias);
+            }
+            // set hidden command aliases
+            for (const alias of command.hiddenAliases ?? []) {
+                handleAlias(alias, true);
+            }
+        }
+        marker?.addDetails({ commandCount: plugin.commands.length });
+        marker?.stop();
+    }
+    loadTopics(plugin) {
+        const marker = performance_1.Performance.mark(performance_1.OCLIF_MARKER_OWNER, `config.loadTopics#${plugin.name}`, { plugin: plugin.name });
+        for (const topic of (0, util_2.compact)(plugin.topics)) {
+            const existing = this._topics.get(topic.name);
+            if (existing) {
+                existing.description = topic.description || existing.description;
+                existing.hidden = existing.hidden || topic.hidden;
+            }
+            else {
+                this._topics.set(topic.name, topic);
+            }
+            const permutations = this.flexibleTaxonomy ? (0, util_3.getCommandIdPermutations)(topic.name) : [topic.name];
+            for (const permutation of permutations) {
+                this.topicPermutations.add(permutation, topic.name);
+            }
+        }
+        // Add missing topics for displaying help when partial commands are entered.
+        for (const c of plugin.commands.filter((c) => !c.hidden)) {
+            const parts = c.id.split(':');
+            while (parts.length > 0) {
+                const name = parts.join(':');
+                if (name && !this._topics.has(name)) {
+                    this._topics.set(name, { description: c.summary || c.description, name });
+                }
+                parts.pop();
+            }
+        }
+        marker?.stop();
+    }
+    maybeAdjustDebugSetting() {
+        if (this.scopedEnvVarTrue('DEBUG')) {
+            settings_1.settings.debug = true;
+            displayWarnings();
+        }
+    }
+    warn(err, scope) {
+        if (this.warned)
+            return;
+        if (typeof err === 'string') {
+            process.emitWarning(err);
+            return;
+        }
+        if (err instanceof Error) {
+            const modifiedErr = err;
+            modifiedErr.name = `${err.name} Plugin: ${this.name}`;
+            modifiedErr.detail = (0, util_2.compact)([
+                err.detail,
+                `module: ${this._base}`,
+                scope && `task: ${scope}`,
+                `plugin: ${this.name}`,
+                `root: ${this.root}`,
+                'See more details with DEBUG=*',
+            ]).join('\n');
+            process.emitWarning(err);
+            return;
+        }
+        // err is an object
+        process.emitWarning('Config.warn expected either a string or Error, but instead received an object');
+        err.name = `${err.name} Plugin: ${this.name}`;
+        err.detail = (0, util_2.compact)([
+            err.detail,
+            `module: ${this._base}`,
+            scope && `task: ${scope}`,
+            `plugin: ${this.name}`,
+            `root: ${this.root}`,
+            'See more details with DEBUG=*',
+        ]).join('\n');
+        process.emitWarning(JSON.stringify(err));
+    }
+}
+exports.Config = Config;

node_modules/@oclif/core/lib/config/index.d.ts

@@ -0,0 +1,3 @@
+export { Config } from './config';
+export { Plugin } from './plugin';
+export { tsPath } from './ts-path';

node_modules/@oclif/core/lib/config/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tsPath = exports.Plugin = exports.Config = void 0;
+var config_1 = require("./config");
+Object.defineProperty(exports, "Config", { enumerable: true, get: function () { return config_1.Config; } });
+var plugin_1 = require("./plugin");
+Object.defineProperty(exports, "Plugin", { enumerable: true, get: function () { return plugin_1.Plugin; } });
+var ts_path_1 = require("./ts-path");
+Object.defineProperty(exports, "tsPath", { enumerable: true, get: function () { return ts_path_1.tsPath; } });

node_modules/@oclif/core/lib/config/plugin-loader.d.ts

@@ -0,0 +1,38 @@
+import { PJSON } from '../interfaces';
+import { Plugin as IPlugin } from '../interfaces/plugin';
+type PluginLoaderOptions = {
+    plugins?: IPlugin[] | PluginsMap | undefined;
+    root: string;
+};
+type LoadOpts = {
+    dataDir: string;
+    devPlugins?: boolean | undefined;
+    force?: boolean | undefined;
+    rootPlugin: IPlugin;
+    userPlugins?: boolean | undefined;
+    pluginAdditions?: {
+        core?: string[];
+        dev?: string[];
+        path?: string;
+    } | undefined;
+};
+type PluginsMap = Map<string, IPlugin>;
+export default class PluginLoader {
+    options: PluginLoaderOptions;
+    errors: (Error | string)[];
+    plugins: PluginsMap;
+    private pluginsProvided;
+    constructor(options: PluginLoaderOptions);
+    loadChildren(opts: LoadOpts): Promise<{
+        errors: (Error | string)[];
+        plugins: PluginsMap;
+    }>;
+    loadRoot({ pjson }: {
+        pjson?: PJSON | undefined;
+    }): Promise<IPlugin>;
+    private loadCorePlugins;
+    private loadDevPlugins;
+    private loadPlugins;
+    private loadUserPlugins;
+}
+export {};

node_modules/@oclif/core/lib/config/plugin-loader.js

@@ -0,0 +1,188 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const minimatch_1 = require("minimatch");
+const node_path_1 = require("node:path");
+const performance_1 = require("../performance");
+const fs_1 = require("../util/fs");
+const util_1 = require("../util/util");
+const plugin_1 = require("./plugin");
+const util_2 = require("./util");
+const debug = (0, util_2.makeDebug)();
+function findMatchingDependencies(dependencies, patterns) {
+    return Object.keys(dependencies).filter((p) => patterns.some((w) => (0, minimatch_1.minimatch)(p, w)));
+}
+class PluginLoader {
+    options;
+    errors = [];
+    plugins = new Map();
+    pluginsProvided = false;
+    constructor(options) {
+        this.options = options;
+        if (options.plugins) {
+            this.pluginsProvided = true;
+            this.plugins = Array.isArray(options.plugins) ? new Map(options.plugins.map((p) => [p.name, p])) : options.plugins;
+        }
+    }
+    async loadChildren(opts) {
+        if (!this.pluginsProvided || opts.force) {
+            await this.loadUserPlugins(opts);
+            await this.loadDevPlugins(opts);
+            await this.loadCorePlugins(opts);
+        }
+        return { errors: this.errors, plugins: this.plugins };
+    }
+    async loadRoot({ pjson }) {
+        let rootPlugin;
+        if (this.pluginsProvided) {
+            const plugins = [...this.plugins.values()];
+            rootPlugin = plugins.find((p) => p.root === this.options.root) ?? plugins[0];
+        }
+        else {
+            const marker = performance_1.Performance.mark(performance_1.OCLIF_MARKER_OWNER, 'plugin.load#root');
+            rootPlugin = new plugin_1.Plugin({ isRoot: true, pjson, root: this.options.root });
+            await rootPlugin.load();
+            marker?.addDetails({
+                commandCount: rootPlugin.commands.length,
+                hasManifest: rootPlugin.hasManifest ?? false,
+                name: rootPlugin.name,
+                topicCount: rootPlugin.topics.length,
+                type: rootPlugin.type,
+                usesMain: Boolean(rootPlugin.pjson.main),
+            });
+            marker?.stop();
+        }
+        this.plugins.set(rootPlugin.name, rootPlugin);
+        return rootPlugin;
+    }
+    async loadCorePlugins(opts) {
+        const { plugins: corePlugins } = opts.rootPlugin.pjson.oclif;
+        if (corePlugins) {
+            const plugins = findMatchingDependencies(opts.rootPlugin.pjson.dependencies ?? {}, corePlugins);
+            await this.loadPlugins(opts.rootPlugin.root, 'core', plugins);
+        }
+        const { core: pluginAdditionsCore, path } = opts.pluginAdditions ?? { core: [] };
+        if (pluginAdditionsCore) {
+            if (path) {
+                // If path is provided, load plugins from the path
+                const pjson = await (0, fs_1.readJson)((0, node_path_1.join)(path, 'package.json'));
+                const plugins = findMatchingDependencies(pjson.dependencies ?? {}, pluginAdditionsCore);
+                await this.loadPlugins(path, 'core', plugins);
+            }
+            else {
+                const plugins = findMatchingDependencies(opts.rootPlugin.pjson.dependencies ?? {}, pluginAdditionsCore);
+                await this.loadPlugins(opts.rootPlugin.root, 'core', plugins);
+            }
+        }
+    }
+    async loadDevPlugins(opts) {
+        if (opts.devPlugins !== false) {
+            // do not load oclif.devPlugins in production
+            if ((0, util_1.isProd)())
+                return;
+            try {
+                const { devPlugins } = opts.rootPlugin.pjson.oclif;
+                if (devPlugins) {
+                    const allDeps = { ...opts.rootPlugin.pjson.dependencies, ...opts.rootPlugin.pjson.devDependencies };
+                    const plugins = findMatchingDependencies(allDeps ?? {}, devPlugins);
+                    await this.loadPlugins(opts.rootPlugin.root, 'dev', plugins);
+                }
+                const { dev: pluginAdditionsDev, path } = opts.pluginAdditions ?? { core: [] };
+                if (pluginAdditionsDev) {
+                    if (path) {
+                        // If path is provided, load plugins from the path
+                        const pjson = await (0, fs_1.readJson)((0, node_path_1.join)(path, 'package.json'));
+                        const allDeps = { ...pjson.dependencies, ...pjson.devDependencies };
+                        const plugins = findMatchingDependencies(allDeps ?? {}, pluginAdditionsDev);
+                        await this.loadPlugins(path, 'dev', plugins);
+                    }
+                    else {
+                        const allDeps = { ...opts.rootPlugin.pjson.dependencies, ...opts.rootPlugin.pjson.devDependencies };
+                        const plugins = findMatchingDependencies(allDeps ?? {}, pluginAdditionsDev);
+                        await this.loadPlugins(opts.rootPlugin.root, 'dev', plugins);
+                    }
+                }
+            }
+            catch (error) {
+                process.emitWarning(error);
+            }
+        }
+    }
+    async loadPlugins(root, type, plugins, parent) {
+        if (!plugins || plugins.length === 0)
+            return;
+        const mark = performance_1.Performance.mark(performance_1.OCLIF_MARKER_OWNER, `config.loadPlugins#${type}`);
+        debug('loading plugins', plugins);
+        await Promise.all((plugins || []).map(async (plugin) => {
+            try {
+                const name = typeof plugin === 'string' ? plugin : plugin.name;
+                const opts = {
+                    name,
+                    root,
+                    type,
+                };
+                if (typeof plugin !== 'string') {
+                    opts.tag = plugin.tag || opts.tag;
+                    opts.root = plugin.root || opts.root;
+                    opts.url = plugin.url;
+                }
+                if (parent) {
+                    opts.parent = parent;
+                }
+                if (this.plugins.has(name))
+                    return;
+                const pluginMarker = performance_1.Performance.mark(performance_1.OCLIF_MARKER_OWNER, `plugin.load#${name}`);
+                const instance = new plugin_1.Plugin(opts);
+                await instance.load();
+                pluginMarker?.addDetails({
+                    commandCount: instance.commands.length,
+                    hasManifest: instance.hasManifest,
+                    name: instance.name,
+                    topicCount: instance.topics.length,
+                    type: instance.type,
+                    usesMain: Boolean(instance.pjson.main),
+                });
+                pluginMarker?.stop();
+                this.plugins.set(instance.name, instance);
+                if (parent) {
+                    instance.parent = parent;
+                    if (!parent.children)
+                        parent.children = [];
+                    parent.children.push(instance);
+                }
+                if (instance.pjson.oclif.plugins) {
+                    const allDeps = type === 'dev'
+                        ? { ...instance.pjson.dependencies, ...instance.pjson.devDependencies }
+                        : instance.pjson.dependencies;
+                    const plugins = findMatchingDependencies(allDeps ?? {}, instance.pjson.oclif.plugins);
+                    await this.loadPlugins(instance.root, type, plugins, instance);
+                }
+            }
+            catch (error) {
+                this.errors.push(error);
+            }
+        }));
+        mark?.addDetails({ pluginCount: plugins.length });
+        mark?.stop();
+    }
+    async loadUserPlugins(opts) {
+        if (opts.userPlugins !== false) {
+            try {
+                const userPJSONPath = (0, node_path_1.join)(opts.dataDir, 'package.json');
+                debug('reading user plugins pjson %s', userPJSONPath);
+                // ignore cache because the file might have changed within the same process (e.g. during a JIT plugin install)
+                const pjson = await (0, fs_1.readJson)(userPJSONPath, false);
+                if (!pjson.oclif)
+                    pjson.oclif = { schema: 1 };
+                if (!pjson.oclif.plugins)
+                    pjson.oclif.plugins = [];
+                await this.loadPlugins(userPJSONPath, 'user', pjson.oclif.plugins.filter((p) => p.type === 'user'));
+                await this.loadPlugins(userPJSONPath, 'link', pjson.oclif.plugins.filter((p) => p.type === 'link'));
+            }
+            catch (error) {
+                if (error.code !== 'ENOENT')
+                    process.emitWarning(error);
+            }
+        }
+    }
+}
+exports.default = PluginLoader;

node_modules/@oclif/core/lib/config/plugin.d.ts

@@ -0,0 +1,51 @@
+import { Command } from '../command';
+import { Manifest } from '../interfaces/manifest';
+import { HookOptions, PJSON } from '../interfaces/pjson';
+import { Plugin as IPlugin, PluginOptions } from '../interfaces/plugin';
+import { Topic } from '../interfaces/topic';
+export declare class Plugin implements IPlugin {
+    options: PluginOptions;
+    _base: string;
+    protected _debug: (..._: any) => void;
+    alias: string;
+    alreadyLoaded: boolean;
+    children: Plugin[];
+    commandIDs: string[];
+    commands: Command.Loadable[];
+    commandsDir: string | undefined;
+    hasManifest: boolean;
+    hooks: {
+        [key: string]: HookOptions[];
+    };
+    isRoot: boolean;
+    manifest: Manifest;
+    moduleType: 'commonjs' | 'module';
+    name: string;
+    parent?: Plugin | undefined;
+    pjson: PJSON;
+    root: string;
+    tag?: string | undefined;
+    type: string;
+    valid: boolean;
+    version: string;
+    private commandCache;
+    private commandDiscoveryOpts;
+    private flexibleTaxonomy;
+    constructor(options: PluginOptions);
+    get topics(): Topic[];
+    findCommand(id: string, opts: {
+        must: true;
+    }): Promise<Command.Class>;
+    findCommand(id: string, opts?: {
+        must: boolean;
+    }): Promise<Command.Class | undefined>;
+    load(): Promise<void>;
+    private _manifest;
+    private addErrorScope;
+    private getCommandIDs;
+    private getCommandIdsFromPattern;
+    private getCommandIdsFromTarget;
+    private getCommandsDir;
+    private loadCommandsFromTarget;
+    private warn;
+}

node_modules/@oclif/core/lib/config/plugin.js

@@ -0,0 +1,374 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Plugin = void 0;
+const node_path_1 = require("node:path");
+const node_util_1 = require("node:util");
+const tinyglobby_1 = require("tinyglobby");
+const cache_1 = __importDefault(require("../cache"));
+const errors_1 = require("../errors");
+const module_loader_1 = require("../module-loader");
+const performance_1 = require("../performance");
+const symbols_1 = require("../symbols");
+const cache_command_1 = require("../util/cache-command");
+const find_root_1 = require("../util/find-root");
+const fs_1 = require("../util/fs");
+const read_pjson_1 = require("../util/read-pjson");
+const util_1 = require("../util/util");
+const ts_path_1 = require("./ts-path");
+const util_2 = require("./util");
+const _pjson = cache_1.default.getInstance().get('@oclif/core');
+function topicsToArray(input, base) {
+    if (!input)
+        return [];
+    base = base ? `${base}:` : '';
+    if (Array.isArray(input)) {
+        return [...input, input.flatMap((t) => topicsToArray(t.subtopics, `${base}${t.name}`))];
+    }
+    return Object.keys(input).flatMap((k) => {
+        input[k].name = k;
+        return [{ ...input[k], name: `${base}${k}` }, ...topicsToArray(input[k].subtopics, `${base}${input[k].name}`)];
+    });
+}
+const cachedCommandCanBeUsed = (manifest, id) => Boolean(manifest?.commands[id] && 'isESM' in manifest.commands[id] && 'relativePath' in manifest.commands[id]);
+const searchForCommandClass = (cmd) => {
+    if (typeof cmd.run === 'function')
+        return cmd;
+    if (cmd.default && cmd.default.run)
+        return cmd.default;
+    return Object.values(cmd).find((cmd) => typeof cmd.run === 'function');
+};
+const ensureCommandClass = (cmd) => {
+    if (cmd && typeof cmd.run === 'function')
+        return cmd;
+};
+const GLOB_PATTERNS = [
+    '**/*.+(js|cjs|mjs|ts|tsx|mts|cts)',
+    '!**/*.+(d.ts|test.ts|test.js|spec.ts|spec.js|d.mts|d.cts)?(x)',
+];
+function processCommandIds(files) {
+    return files.map((file) => {
+        const p = (0, node_path_1.parse)(file);
+        const topics = p.dir.split('/');
+        const command = p.name !== 'index' && p.name;
+        const id = [...topics, command].filter(Boolean).join(':');
+        return id === '' ? symbols_1.SINGLE_COMMAND_CLI_SYMBOL : id;
+    });
+}
+function determineCommandDiscoveryOptions(commandDiscovery) {
+    if (!commandDiscovery)
+        return;
+    if (typeof commandDiscovery === 'string') {
+        return { globPatterns: GLOB_PATTERNS, strategy: 'pattern', target: commandDiscovery };
+    }
+    if (!commandDiscovery.target)
+        throw new errors_1.CLIError('`oclif.commandDiscovery.target` is required.');
+    if (!commandDiscovery.strategy)
+        throw new errors_1.CLIError('`oclif.commandDiscovery.strategy` is required.');
+    if (commandDiscovery.strategy === 'explicit' && !commandDiscovery.identifier) {
+        commandDiscovery.identifier = 'default';
+    }
+    return commandDiscovery;
+}
+function determineHookOptions(hook) {
+    if (typeof hook === 'string')
+        return { identifier: 'default', target: hook };
+    if (!hook.identifier)
+        return { ...hook, identifier: 'default' };
+    return hook;
+}
+class Plugin {
+    options;
+    _base = `${_pjson.name}@${_pjson.version}`;
+    _debug = (0, util_2.makeDebug)();
+    alias;
+    alreadyLoaded = false;
+    children = [];
+    commandIDs = [];
+    // This will be initialized in the _manifest() method, which gets called in the load() method.
+    commands;
+    commandsDir;
+    hasManifest = false;
+    hooks;
+    isRoot = false;
+    manifest;
+    moduleType;
+    name;
+    parent;
+    pjson;
+    root;
+    tag;
+    type;
+    valid = false;
+    version;
+    commandCache;
+    commandDiscoveryOpts;
+    flexibleTaxonomy;
+    constructor(options) {
+        this.options = options;
+    }
+    get topics() {
+        return topicsToArray(this.pjson.oclif.topics || {});
+    }
+    async findCommand(id, opts = {}) {
+        const marker = performance_1.Performance.mark(performance_1.OCLIF_MARKER_OWNER, `plugin.findCommand#${this.name}.${id}`, {
+            id,
+            plugin: this.name,
+        });
+        const fetch = async () => {
+            if (this.commandDiscoveryOpts?.strategy === 'pattern') {
+                const commandsDir = await this.getCommandsDir();
+                if (!commandsDir)
+                    return;
+                let module;
+                let isESM;
+                let filePath;
+                try {
+                    ;
+                    ({ filePath, isESM, module } = cachedCommandCanBeUsed(this.manifest, id)
+                        ? await (0, module_loader_1.loadWithDataFromManifest)(this.manifest.commands[id], this.root)
+                        : await (0, module_loader_1.loadWithData)(this, (0, node_path_1.join)(commandsDir ?? this.pjson.oclif.commands, ...id.split(':'))));
+                    this._debug(isESM ? '(import)' : '(require)', filePath);
+                }
+                catch (error) {
+                    if (!opts.must && error.code === 'MODULE_NOT_FOUND')
+                        return;
+                    throw error;
+                }
+                const cmd = searchForCommandClass(module);
+                if (!cmd)
+                    return;
+                cmd.id = id;
+                cmd.plugin = this;
+                cmd.isESM = isESM;
+                cmd.relativePath = (0, node_path_1.relative)(this.root, filePath || '').split(node_path_1.sep);
+                return cmd;
+            }
+            if (this.commandDiscoveryOpts?.strategy === 'single' || this.commandDiscoveryOpts?.strategy === 'explicit') {
+                const commandCache = await this.loadCommandsFromTarget();
+                const cmd = ensureCommandClass(commandCache?.[id]);
+                if (!cmd)
+                    return;
+                cmd.id = id;
+                cmd.plugin = this;
+                return cmd;
+            }
+        };
+        const cmd = await fetch();
+        if (!cmd && opts.must)
+            (0, errors_1.error)(`command ${id} not found`);
+        marker?.stop();
+        return cmd;
+    }
+    // eslint-disable-next-line complexity
+    async load() {
+        this.type = this.options.type ?? 'core';
+        this.tag = this.options.tag;
+        this.isRoot = this.options.isRoot ?? false;
+        if (this.options.parent)
+            this.parent = this.options.parent;
+        // Linked plugins already have a root so there's no need to search for it.
+        // However there could be child plugins nested inside the linked plugin, in which
+        // case we still need to search for the child plugin's root.
+        const root = this.options.pjson && this.options.isRoot
+            ? this.options.root
+            : this.type === 'link' && !this.parent
+                ? this.options.root
+                : await (0, find_root_1.findRoot)(this.options.name, this.options.root);
+        if (!root)
+            throw new errors_1.CLIError(`could not find package.json with ${(0, node_util_1.inspect)(this.options)}`);
+        this.root = root;
+        this._debug(`loading ${this.type} plugin from ${root}`);
+        this.pjson = this.options.pjson ?? (await (0, read_pjson_1.readPjson)(root));
+        this.flexibleTaxonomy = this.options?.flexibleTaxonomy || this.pjson.oclif?.flexibleTaxonomy || false;
+        this.moduleType = this.pjson.type === 'module' ? 'module' : 'commonjs';
+        this.name = this.pjson.name;
+        this.alias = this.options.name ?? this.pjson.name;
+        if (!this.name)
+            throw new errors_1.CLIError(`no name in package.json (${root})`);
+        this._debug = (0, util_2.makeDebug)(this.name);
+        this.version = this.pjson.version;
+        if (this.pjson.oclif) {
+            this.valid = true;
+        }
+        else {
+            this.pjson.oclif = this.pjson['cli-engine'] || {};
+        }
+        this.hooks = Object.fromEntries(Object.entries(this.pjson.oclif.hooks ?? {}).map(([k, v]) => [
+            k,
+            (0, util_1.castArray)(v).map((v) => determineHookOptions(v)),
+        ]));
+        this.commandDiscoveryOpts = determineCommandDiscoveryOptions(this.pjson.oclif?.commands);
+        this._debug('command discovery options', this.commandDiscoveryOpts);
+        this.manifest = await this._manifest();
+        this.commands = Object.entries(this.manifest.commands)
+            .map(([id, c]) => ({
+            ...c,
+            load: async () => this.findCommand(id, { must: true }),
+            pluginAlias: this.alias,
+            pluginType: c.pluginType === 'jit' ? 'jit' : this.type,
+        }))
+            .sort((a, b) => a.id.localeCompare(b.id));
+    }
+    async _manifest() {
+        const ignoreManifest = Boolean(this.options.ignoreManifest);
+        const errorOnManifestCreate = Boolean(this.options.errorOnManifestCreate);
+        const respectNoCacheDefault = Boolean(this.options.respectNoCacheDefault);
+        const readManifest = async (dotfile = false) => {
+            try {
+                const p = (0, node_path_1.join)(this.root, `${dotfile ? '.' : ''}oclif.manifest.json`);
+                const manifest = await (0, fs_1.readJson)(p);
+                if (!process.env.OCLIF_NEXT_VERSION && manifest.version.split('-')[0] !== this.version.split('-')[0]) {
+                    process.emitWarning(`Mismatched version in ${this.name} plugin manifest. Expected: ${this.version} Received: ${manifest.version}\nThis usually means you have an oclif.manifest.json file that should be deleted in development. This file should be automatically generated when publishing.`);
+                }
+                else {
+                    this._debug('using manifest from', p);
+                    this.hasManifest = true;
+                    return manifest;
+                }
+            }
+            catch (error) {
+                if (error.code === 'ENOENT') {
+                    if (!dotfile)
+                        return readManifest(true);
+                }
+                else {
+                    this.warn(error, 'readManifest');
+                }
+            }
+        };
+        const marker = performance_1.Performance.mark(performance_1.OCLIF_MARKER_OWNER, `plugin.manifest#${this.name}`, { plugin: this.name });
+        if (!ignoreManifest) {
+            const manifest = await readManifest();
+            if (manifest) {
+                marker?.addDetails({ commandCount: Object.keys(manifest.commands).length, fromCache: true });
+                marker?.stop();
+                this.commandIDs = Object.keys(manifest.commands);
+                return manifest;
+            }
+        }
+        this.commandIDs = await this.getCommandIDs();
+        const manifest = {
+            commands: (await Promise.all(this.commandIDs.map(async (id) => {
+                try {
+                    const found = await this.findCommand(id, { must: true });
+                    const cached = await (0, cache_command_1.cacheCommand)(found, this, respectNoCacheDefault);
+                    // Ensure that id is set to the id being processed
+                    // This is necessary because the id is set by findCommand but if there
+                    // are multiple instances of a Command, then the id will be set to the
+                    // last one found.
+                    cached.id = id;
+                    if (this.flexibleTaxonomy) {
+                        const permutations = (0, util_2.getCommandIdPermutations)(id);
+                        const aliasPermutations = cached.aliases.flatMap((a) => (0, util_2.getCommandIdPermutations)(a));
+                        return [id, { ...cached, aliasPermutations, permutations }];
+                    }
+                    return [id, cached];
+                }
+                catch (error) {
+                    const scope = `findCommand (${id})`;
+                    if (Boolean(errorOnManifestCreate) === false)
+                        this.warn(error, scope);
+                    else
+                        throw this.addErrorScope(error, scope);
+                }
+            })))
+                // eslint-disable-next-line unicorn/prefer-native-coercion-functions
+                .filter((f) => Boolean(f))
+                .reduce((commands, [id, c]) => {
+                commands[id] = c;
+                return commands;
+            }, {}),
+            version: this.version,
+        };
+        marker?.addDetails({ commandCount: Object.keys(manifest.commands).length, fromCache: false });
+        marker?.stop();
+        return manifest;
+    }
+    addErrorScope(err, scope) {
+        err.name = err.name ?? (0, node_util_1.inspect)(err).trim();
+        err.detail = (0, util_1.compact)([
+            err.detail,
+            `module: ${this._base}`,
+            scope && `task: ${scope}`,
+            `plugin: ${this.name}`,
+            `root: ${this.root}`,
+            ...(err.code ? [`code: ${err.code}`] : []),
+            ...(err.message ? [`message: ${err.message}`] : []),
+            'See more details with DEBUG=*',
+        ]).join('\n');
+        return err;
+    }
+    async getCommandIDs() {
+        const marker = performance_1.Performance.mark(performance_1.OCLIF_MARKER_OWNER, `plugin.getCommandIDs#${this.name}`, { plugin: this.name });
+        let ids;
+        switch (this.commandDiscoveryOpts?.strategy) {
+            case 'explicit': {
+                ids = (await this.getCommandIdsFromTarget()) ?? [];
+                break;
+            }
+            case 'pattern': {
+                ids = await this.getCommandIdsFromPattern();
+                break;
+            }
+            case 'single': {
+                ids = (await this.getCommandIdsFromTarget()) ?? [];
+                break;
+            }
+            default: {
+                ids = [];
+            }
+        }
+        this._debug('found commands', ids);
+        marker?.addDetails({ count: ids.length });
+        marker?.stop();
+        return ids;
+    }
+    async getCommandIdsFromPattern() {
+        const commandsDir = await this.getCommandsDir();
+        if (!commandsDir)
+            return [];
+        this._debug(`loading IDs from ${commandsDir}`);
+        const files = await (0, tinyglobby_1.glob)(this.commandDiscoveryOpts?.globPatterns ?? GLOB_PATTERNS, { cwd: commandsDir });
+        return processCommandIds(files);
+    }
+    async getCommandIdsFromTarget() {
+        const commandsFromExport = await this.loadCommandsFromTarget();
+        if (commandsFromExport) {
+            return Object.entries((await this.loadCommandsFromTarget()) ?? [])
+                .filter(([, cmd]) => ensureCommandClass(cmd))
+                .map(([id]) => id);
+        }
+    }
+    async getCommandsDir() {
+        if (this.commandsDir)
+            return this.commandsDir;
+        this.commandsDir = await (0, ts_path_1.tsPath)(this.root, this.commandDiscoveryOpts?.target, this);
+        return this.commandsDir;
+    }
+    async loadCommandsFromTarget() {
+        if (this.commandCache)
+            return this.commandCache;
+        if (this.commandDiscoveryOpts?.strategy === 'explicit' && this.commandDiscoveryOpts.target) {
+            const filePath = await (0, ts_path_1.tsPath)(this.root, this.commandDiscoveryOpts.target, this);
+            const module = await (0, module_loader_1.load)(this, filePath);
+            this.commandCache = module[this.commandDiscoveryOpts?.identifier ?? 'default'] ?? {};
+            return this.commandCache;
+        }
+        if (this.commandDiscoveryOpts?.strategy === 'single' && this.commandDiscoveryOpts.target) {
+            const filePath = await (0, ts_path_1.tsPath)(this.root, this.commandDiscoveryOpts?.target ?? this.root, this);
+            const module = await (0, module_loader_1.load)(this, filePath);
+            this.commandCache = { [symbols_1.SINGLE_COMMAND_CLI_SYMBOL]: searchForCommandClass(module) };
+            return this.commandCache;
+        }
+    }
+    warn(err, scope) {
+        if (typeof err === 'string')
+            err = new Error(err);
+        const warning = this.addErrorScope(err, scope);
+        process.emitWarning(warning.name, warning);
+    }
+}
+exports.Plugin = Plugin;

node_modules/@oclif/core/lib/config/ts-path.d.ts

@@ -0,0 +1,9 @@
+import { Plugin, TSConfig } from '../interfaces';
+export declare const TS_CONFIGS: Record<string, TSConfig | undefined>;
+/**
+ * Convert a path from the compiled ./lib files to the ./src typescript source
+ * this is for developing typescript plugins/CLIs
+ * if there is a tsconfig and the original sources exist, it attempts to require ts-node
+ */
+export declare function tsPath(root: string, orig: string, plugin: Plugin): Promise<string>;
+export declare function tsPath(root: string, orig: string | undefined, plugin?: Plugin | undefined): Promise<string | undefined>;

node_modules/@oclif/core/lib/config/ts-path.js

@@ -0,0 +1,293 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TS_CONFIGS = void 0;
+exports.tsPath = tsPath;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const node_url_1 = require("node:url");
+const cache_1 = __importDefault(require("../cache"));
+const warn_1 = require("../errors/warn");
+const settings_1 = require("../settings");
+const fs_1 = require("../util/fs");
+const read_tsconfig_1 = require("../util/read-tsconfig");
+const util_1 = require("../util/util");
+const util_2 = require("./util");
+const debug = (0, util_2.makeDebug)('ts-path');
+exports.TS_CONFIGS = {};
+const REGISTERED = new Set();
+function determineRuntime() {
+    /**
+     * Examples:
+     * #!/usr/bin/env bun
+     * bun bin/run.js
+     * bun bin/dev.js
+     */
+    if (process.execPath.split(node_path_1.sep).includes('bun'))
+        return 'bun';
+    /**
+     * Examples:
+     * #!/usr/bin/env node
+     * #!/usr/bin/env node --loader ts-node/esm --experimental-specifier-resolution=node --no-warnings
+     * node bin/run.js
+     * node bin/dev.js
+     */
+    if (process.execArgv.length === 0)
+        return 'node';
+    /**
+     * Examples:
+     * #!/usr/bin/env ts-node
+     * #!/usr/bin/env node_modules/.bin/ts-node
+     * ts-node bin/run.js
+     * ts-node bin/dev.js
+     */
+    if (process.execArgv[0] === '--require' && process.execArgv[1].split(node_path_1.sep).includes('ts-node'))
+        return 'ts-node';
+    if (process.execArgv[0].split(node_path_1.sep).includes('ts-node'))
+        return 'ts-node';
+    /**
+     * Examples:
+     * #!/usr/bin/env tsx
+     * #!/usr/bin/env node_modules/.bin/tsx
+     * tsx bin/run.js
+     * tsx bin/dev.js
+     */
+    if (process.execArgv[0] === '--require' && process.execArgv[1].split(node_path_1.sep).includes('tsx'))
+        return 'tsx';
+    return 'node';
+}
+const RUN_TIME = determineRuntime();
+function isErrno(error) {
+    return 'code' in error && error.code === 'ENOENT';
+}
+async function loadTSConfig(root) {
+    try {
+        if (exports.TS_CONFIGS[root])
+            return exports.TS_CONFIGS[root];
+        const tsconfig = await (0, read_tsconfig_1.readTSConfig)(root);
+        if (!tsconfig)
+            return;
+        debug('tsconfig: %O', tsconfig);
+        exports.TS_CONFIGS[root] = tsconfig;
+        return exports.TS_CONFIGS[root];
+    }
+    catch (error) {
+        if (isErrno(error))
+            return;
+        debug(`Could not parse tsconfig.json. Skipping typescript path lookup for ${root}.`);
+        (0, warn_1.memoizedWarn)(`Could not parse tsconfig.json for ${root}. Falling back to compiled source.`);
+    }
+}
+async function registerTsx(root, moduleType) {
+    if (REGISTERED.has(root))
+        return;
+    try {
+        const apiPath = moduleType === 'module' ? 'tsx/esm/api' : 'tsx/cjs/api';
+        const tsxPath = require.resolve(apiPath, { paths: [root] });
+        if (!tsxPath)
+            return;
+        debug('registering tsx at', root);
+        debug('tsx path:', tsxPath);
+        const { href } = (0, node_url_1.pathToFileURL)(tsxPath);
+        debug('tsx href:', href);
+        const { register } = await import(href);
+        debug('Successfully imported tsx');
+        register();
+        REGISTERED.add(root);
+    }
+    catch (error) {
+        debug(`Could not find tsx. Skipping tsx registration for ${root}.`);
+        debug(error);
+    }
+}
+async function registerTSNode(root, tsconfig) {
+    if (REGISTERED.has(root))
+        return;
+    debug('registering ts-node at', root);
+    const tsNodePath = require.resolve('ts-node', { paths: [root, __dirname] });
+    debug('ts-node path:', tsNodePath);
+    let tsNode;
+    try {
+        tsNode = require(tsNodePath);
+        debug('Successfully required ts-node');
+    }
+    catch (error) {
+        debug(`Could not find ts-node at ${tsNodePath}. Skipping ts-node registration for ${root}.`);
+        debug(error);
+        (0, warn_1.memoizedWarn)(`Could not find ts-node at ${tsNodePath}. Please ensure that ts-node is a devDependency. Falling back to compiled source.`);
+        return;
+    }
+    const typeRoots = [(0, node_path_1.join)(root, 'node_modules', '@types')];
+    const rootDirs = [];
+    if (tsconfig.compilerOptions.rootDirs) {
+        for (const r of tsconfig.compilerOptions.rootDirs) {
+            rootDirs.push((0, node_path_1.join)(root, r));
+        }
+    }
+    else if (tsconfig.compilerOptions.rootDir) {
+        rootDirs.push((0, node_path_1.join)(root, tsconfig.compilerOptions.rootDir));
+    }
+    else if (tsconfig.compilerOptions.baseUrl) {
+        rootDirs.push((0, node_path_1.join)(root, tsconfig.compilerOptions.baseUrl));
+    }
+    else {
+        rootDirs.push((0, node_path_1.join)(root, 'src'));
+    }
+    // Because we need to provide a modified `rootDirs` to ts-node, we need to
+    // remove `baseUrl` and `rootDir` from `compilerOptions` so that they
+    // don't conflict.
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const { baseUrl, rootDir, ...rest } = tsconfig.compilerOptions;
+    const conf = {
+        compilerOptions: {
+            ...rest,
+            rootDirs,
+            typeRoots,
+        },
+        ...tsconfig['ts-node'],
+        cwd: root,
+        esm: tsconfig['ts-node']?.esm ?? true,
+        experimentalSpecifierResolution: tsconfig['ts-node']?.experimentalSpecifierResolution ?? 'explicit',
+        scope: true,
+        scopeDir: root,
+        skipProject: true,
+        transpileOnly: true,
+    };
+    debug('ts-node options: %O', conf);
+    tsNode.register(conf);
+    REGISTERED.add(root);
+}
+/**
+ * Skip ts-node registration for ESM plugins in production.
+ * The node/ts-node ecosystem is not mature enough to support auto-transpiling ESM modules at this time.
+ * See the following:
+ * - https://github.com/TypeStrong/ts-node/issues/1791#issuecomment-1149754228
+ * - https://github.com/nodejs/node/issues/49432
+ * - https://github.com/nodejs/node/pull/49407
+ * - https://github.com/nodejs/node/issues/34049
+ *
+ * We still register tsx/ts-node for ESM plugins when NODE_ENV is "test" or "development" and root plugin is also ESM
+ * since that allows plugins to be auto-transpiled when developing locally using `bin/dev.js`.
+ */
+function cannotTranspileEsm(rootPlugin, plugin, isProduction) {
+    return ((isProduction || rootPlugin?.moduleType === 'commonjs') &&
+        plugin?.moduleType === 'module' &&
+        !plugin?.pjson.devDependencies?.tsx);
+}
+/**
+ * If the dev script is run with ts-node for an ESM plugin, skip ts-node registration
+ * and fall back on compiled source since ts-node executable cannot transpile ESM in Node 20+
+ *
+ * See the following:
+ * https://nodejs.org/en/blog/announcements/v20-release-announce#custom-esm-loader-hooks-nearing-stable
+ * https://github.com/oclif/core/issues/817
+ * https://github.com/TypeStrong/ts-node/issues/1997
+ */
+function cannotUseTsNode(root, plugin, isProduction) {
+    if (plugin?.moduleType !== 'module' || isProduction)
+        return false;
+    const nodeMajor = Number.parseInt(process.version.replace('v', '').split('.')[0], 10);
+    return RUN_TIME === 'ts-node' && nodeMajor >= 20;
+}
+/**
+ * Determine the path to the source file from the compiled ./lib files
+ */
+async function determinePath(root, orig, plugin) {
+    const tsconfig = await loadTSConfig(root);
+    if (!tsconfig)
+        return orig;
+    debug(`Determining path for ${orig}`);
+    if (RUN_TIME === 'bun') {
+        debug(`Skipping ts-node registration for ${root} because the runtime is: ${RUN_TIME}`);
+    }
+    else {
+        // attempt to register tsx first. If it fails to register, we will fall back to ts-node
+        await registerTsx(root, plugin?.moduleType);
+        // if tsx registration succeeded, then this will exit early since the path will be in REGISTERED already
+        await registerTSNode(root, tsconfig);
+    }
+    const { baseUrl, outDir, rootDir, rootDirs } = tsconfig.compilerOptions;
+    const rootDirPath = rootDir ?? (rootDirs ?? [])[0] ?? baseUrl;
+    if (!rootDirPath) {
+        debug(`no rootDir, rootDirs, or baseUrl specified in tsconfig.json. Returning default path ${orig}`);
+        return orig;
+    }
+    if (!outDir) {
+        debug(`no outDir specified in tsconfig.json. Returning default path ${orig}`);
+        return orig;
+    }
+    // rewrite path from ./lib/foo to ./src/foo
+    const lib = (0, node_path_1.join)(root, outDir); // ./lib
+    const src = (0, node_path_1.join)(root, rootDirPath); // ./src
+    const relative = (0, node_path_1.relative)(lib, orig); // ./commands
+    // For hooks, it might point to a js file, not a module. Something like "./hooks/myhook.js" which doesn't need the js.
+    const out = (0, node_path_1.join)(src, relative).replace(/\.js$/, ''); // ./src/commands
+    // this can be a directory of commands or point to a hook file
+    // if it's a directory, we check if the path exists. If so, return the path to the directory.
+    // For hooks, it might point to a module, not a file. Something like "./hooks/myhook"
+    // That file doesn't exist, and the real file is "./hooks/myhook.ts"
+    // In that case we attempt to resolve to the filename. If it fails it will revert back to the lib path
+    debug(`lib dir: ${lib}`);
+    debug(`src dir: ${src}`);
+    debug(`src directory to find: ${out}`);
+    if ((0, fs_1.existsSync)(out)) {
+        debug(`Found source directory for ${orig} at ${out}`);
+        return out;
+    }
+    const sourceFiles = await Promise.all([
+        (0, promises_1.access)(`${out}.ts`)
+            .then(() => `${out}.ts`)
+            .catch(() => false),
+        (0, promises_1.access)(`${out}.tsx`)
+            .then(() => `${out}.tsx`)
+            .catch(() => false),
+    ]);
+    if (sourceFiles.some(Boolean)) {
+        debug(`Found source file for ${orig} at ${out}`);
+        return out;
+    }
+    debug(`No source file found. Returning default path ${orig}`);
+    if (!(0, util_1.isProd)())
+        (0, warn_1.memoizedWarn)(`Could not find source for ${orig} based on tsconfig. Defaulting to compiled source.`);
+    return orig;
+}
+async function tsPath(root, orig, plugin) {
+    const rootPlugin = plugin?.options.isRoot ? plugin : cache_1.default.getInstance().get('rootPlugin');
+    if (!orig)
+        return orig;
+    orig = orig.startsWith(root) ? orig : (0, node_path_1.join)(root, orig);
+    // NOTE: The order of these checks matter!
+    const enableAutoTranspile = settings_1.settings.enableAutoTranspile ?? settings_1.settings.tsnodeEnabled;
+    if (enableAutoTranspile === false) {
+        debug(`Skipping typescript path lookup for ${root} because enableAutoTranspile is explicitly set to false`);
+        return orig;
+    }
+    const isProduction = (0, util_1.isProd)();
+    // Do not skip ts-node registration if the plugin is linked
+    if (enableAutoTranspile === undefined && isProduction && plugin?.type !== 'link') {
+        debug(`Skipping typescript path lookup for ${root} because NODE_ENV is NOT "test" or "development"`);
+        return orig;
+    }
+    if (cannotTranspileEsm(rootPlugin, plugin, isProduction)) {
+        debug(`Skipping typescript path lookup for ${root} because it's an ESM module (NODE_ENV: ${process.env.NODE_ENV}, root plugin module type: ${rootPlugin?.moduleType})`);
+        const warningIsDisabled = process.env.OCLIF_DISABLE_LINKED_ESM_WARNING && (0, util_1.isTruthy)(process.env.OCLIF_DISABLE_LINKED_ESM_WARNING);
+        // Only warn if the plugin is linked AND the warning is not disabled
+        if (plugin?.type === 'link' && !warningIsDisabled)
+            (0, warn_1.memoizedWarn)(`${plugin?.name} is a linked ESM module and cannot be auto-transpiled. Existing compiled source will be used instead.`);
+        return orig;
+    }
+    if (cannotUseTsNode(root, plugin, isProduction)) {
+        debug(`Skipping typescript path lookup for ${root} because ts-node is run in node version ${process.version}"`);
+        (0, warn_1.memoizedWarn)(`ts-node executable cannot transpile ESM in Node 20. Existing compiled source will be used instead. See https://github.com/oclif/core/issues/817.`);
+        return orig;
+    }
+    try {
+        return await determinePath(root, orig, plugin);
+    }
+    catch (error) {
+        debug(error);
+        return orig;
+    }
+}

node_modules/@oclif/core/lib/config/util.d.ts

@@ -0,0 +1,23 @@
+export declare function makeDebug(...scope: string[]): (..._: any) => void;
+export declare function getPermutations(arr: string[]): Array<string[]>;
+export declare function getCommandIdPermutations(commandId: string): string[];
+/**
+ * Return an array of ids that represent all the usable combinations that a user could enter.
+ *
+ * For example, if the command ids are:
+ * - foo:bar:baz
+ * - one:two:three
+ * Then the usable ids would be:
+ * - foo
+ * - foo:bar
+ * - foo:bar:baz
+ * - one
+ * - one:two
+ * - one:two:three
+ *
+ * This allows us to determine which parts of the argv array belong to the command id whenever the topicSeparator is a space.
+ *
+ * @param commandIds string[]
+ * @returns string[]
+ */
+export declare const collectUsableIds: (commandIds: string[]) => Set<string>;

node_modules/@oclif/core/lib/config/util.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectUsableIds = void 0;
+exports.makeDebug = makeDebug;
+exports.getPermutations = getPermutations;
+exports.getCommandIdPermutations = getCommandIdPermutations;
+const logger_1 = require("../logger");
+function makeDebug(...scope) {
+    return (formatter, ...args) => (0, logger_1.getLogger)(['config', ...scope].join(':')).debug(formatter, ...args);
+}
+// Adapted from https://github.com/angus-c/just/blob/master/packages/array-permutations/index.js
+function getPermutations(arr) {
+    if (arr.length === 0)
+        return [];
+    if (arr.length === 1)
+        return [arr];
+    const output = [];
+    const partialPermutations = getPermutations(arr.slice(1));
+    const first = arr[0];
+    for (let i = 0, len = partialPermutations.length; i < len; i++) {
+        const partial = partialPermutations[i];
+        for (let j = 0, len2 = partial.length; j <= len2; j++) {
+            const start = partial.slice(0, j);
+            const end = partial.slice(j);
+            const merged = [...start, first, ...end];
+            output.push(merged);
+        }
+    }
+    return output;
+}
+function getCommandIdPermutations(commandId) {
+    return getPermutations(commandId.split(':')).flatMap((c) => c.join(':'));
+}
+/**
+ * Return an array of ids that represent all the usable combinations that a user could enter.
+ *
+ * For example, if the command ids are:
+ * - foo:bar:baz
+ * - one:two:three
+ * Then the usable ids would be:
+ * - foo
+ * - foo:bar
+ * - foo:bar:baz
+ * - one
+ * - one:two
+ * - one:two:three
+ *
+ * This allows us to determine which parts of the argv array belong to the command id whenever the topicSeparator is a space.
+ *
+ * @param commandIds string[]
+ * @returns string[]
+ */
+const collectUsableIds = (commandIds) => new Set(commandIds.flatMap((id) => id.split(':').map((_, i, a) => a.slice(0, i + 1).join(':'))));
+exports.collectUsableIds = collectUsableIds;

node_modules/@oclif/core/lib/errors/error.d.ts

@@ -0,0 +1,8 @@
+import { PrettyPrintableError } from '../interfaces';
+export declare function error(input: Error | string, options: {
+    exit: false;
+} & PrettyPrintableError): void;
+export declare function error(input: Error | string, options?: {
+    exit?: number;
+} & PrettyPrintableError): never;
+export default error;

node_modules/@oclif/core/lib/errors/error.js

@@ -0,0 +1,63 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.error = error;
+const logger_1 = require("../logger");
+const write_1 = require("../ux/write");
+const cli_1 = require("./errors/cli");
+const pretty_print_1 = __importStar(require("./errors/pretty-print"));
+function error(input, options = {}) {
+    let err;
+    if (typeof input === 'string') {
+        err = new cli_1.CLIError(input, options);
+    }
+    else if (input instanceof Error) {
+        err = (0, cli_1.addOclifExitCode)(input, options);
+    }
+    else {
+        throw new TypeError('first argument must be a string or instance of Error');
+    }
+    err = (0, pretty_print_1.applyPrettyPrintOptions)(err, options);
+    if (options.exit === false) {
+        const message = (0, pretty_print_1.default)(err);
+        if (message)
+            (0, write_1.stderr)(message);
+        if (err?.stack)
+            (0, logger_1.getLogger)().error(err.stack);
+    }
+    else
+        throw err;
+}
+exports.default = error;

node_modules/@oclif/core/lib/errors/errors/cli.d.ts

@@ -0,0 +1,29 @@
+import { OclifError, PrettyPrintableError } from '../../interfaces/errors';
+/**
+ * properties specific to internal oclif error handling
+ */
+export declare function addOclifExitCode(error: Record<string, any>, options?: {
+    exit?: false | number | undefined;
+}): OclifError;
+export declare class CLIError extends Error implements OclifError {
+    code?: string | undefined;
+    oclif: OclifError['oclif'];
+    skipOclifErrorHandling?: boolean | undefined;
+    suggestions?: string[] | undefined;
+    constructor(error: Error | string, options?: {
+        exit?: false | number | undefined;
+    } & PrettyPrintableError);
+    get bang(): string | undefined;
+    get stack(): string;
+    /**
+     * @deprecated `render` Errors display should be handled by display function, like pretty-print
+     * @returns {string} returns a string representing the display of the error
+     */
+    render(): string;
+}
+export declare namespace CLIError {
+    class Warn extends CLIError {
+        constructor(err: Error | string);
+        get bang(): string | undefined;
+    }
+}

node_modules/@oclif/core/lib/errors/errors/cli.js

@@ -0,0 +1,79 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLIError = void 0;
+exports.addOclifExitCode = addOclifExitCode;
+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 settings_1 = require("../../settings");
+const theme_1 = require("../../ux/theme");
+/**
+ * properties specific to internal oclif error handling
+ */
+function addOclifExitCode(error, options) {
+    if (!('oclif' in error)) {
+        ;
+        error.oclif = {};
+    }
+    error.oclif.exit = options?.exit === undefined ? (cache_1.default.getInstance().get('exitCodes')?.default ?? 2) : options.exit;
+    return error;
+}
+class CLIError extends Error {
+    code;
+    oclif = {};
+    skipOclifErrorHandling;
+    suggestions;
+    constructor(error, options = {}) {
+        super(error instanceof Error ? error.message : error);
+        addOclifExitCode(this, options);
+        this.code = options.code;
+        this.suggestions = options.suggestions;
+    }
+    // eslint-disable-next-line getter-return
+    get bang() {
+        try {
+            return (0, theme_1.colorize)('red', process.platform === 'win32' ? '»' : '›');
+        }
+        catch { }
+    }
+    get stack() {
+        return (0, clean_stack_1.default)(super.stack, { pretty: true });
+    }
+    /**
+     * @deprecated `render` Errors display should be handled by display function, like pretty-print
+     * @returns {string} returns a string representing the display of the error
+     */
+    render() {
+        if (settings_1.settings.debug) {
+            return this.stack;
+        }
+        let output = `${this.name}: ${this.message}`;
+        output = (0, wrap_ansi_1.default)(output, screen_1.errtermwidth - 6, { hard: true, trim: false });
+        output = (0, indent_string_1.default)(output, 3);
+        output = (0, indent_string_1.default)(output, 1, { includeEmptyLines: true, indent: this.bang });
+        output = (0, indent_string_1.default)(output, 1);
+        return output;
+    }
+}
+exports.CLIError = CLIError;
+(function (CLIError) {
+    class Warn extends CLIError {
+        constructor(err) {
+            super(err instanceof Error ? err.message : err);
+            this.name = 'Warning';
+        }
+        // eslint-disable-next-line getter-return
+        get bang() {
+            try {
+                return (0, theme_1.colorize)('yellow', process.platform === 'win32' ? '»' : '›');
+            }
+            catch { }
+        }
+    }
+    CLIError.Warn = Warn;
+})(CLIError || (exports.CLIError = CLIError = {}));

node_modules/@oclif/core/lib/errors/errors/exit.d.ts

@@ -0,0 +1,7 @@
+import { OclifError } from '../../interfaces';
+import { CLIError } from './cli';
+export declare class ExitError extends CLIError implements OclifError {
+    code: string;
+    constructor(exitCode?: number);
+    render(): string;
+}

node_modules/@oclif/core/lib/errors/errors/exit.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExitError = void 0;
+const cli_1 = require("./cli");
+class ExitError extends cli_1.CLIError {
+    code = 'EEXIT';
+    constructor(exitCode = 1) {
+        super(`EEXIT: ${exitCode}`, { exit: exitCode });
+    }
+    render() {
+        return '';
+    }
+}
+exports.ExitError = ExitError;

node_modules/@oclif/core/lib/errors/errors/module-load.d.ts

@@ -0,0 +1,6 @@
+import { OclifError } from '../../interfaces';
+import { CLIError } from './cli';
+export declare class ModuleLoadError extends CLIError implements OclifError {
+    code: string;
+    constructor(message: string);
+}

node_modules/@oclif/core/lib/errors/errors/module-load.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModuleLoadError = void 0;
+const cli_1 = require("./cli");
+class ModuleLoadError extends cli_1.CLIError {
+    code = 'MODULE_NOT_FOUND';
+    constructor(message) {
+        super(`[MODULE_NOT_FOUND] ${message}`, { exit: 1 });
+        this.name = 'ModuleLoadError';
+    }
+}
+exports.ModuleLoadError = ModuleLoadError;

node_modules/@oclif/core/lib/errors/errors/pretty-print.d.ts

@@ -0,0 +1,8 @@
+import { PrettyPrintableError } from '../../interfaces/errors';
+type CLIErrorDisplayOptions = {
+    bang?: string | undefined;
+    name?: string | undefined;
+};
+export declare function applyPrettyPrintOptions(error: Error, options: PrettyPrintableError): PrettyPrintableError;
+export default function prettyPrint(error: Error & PrettyPrintableError & CLIErrorDisplayOptions): string | undefined;
+export {};

node_modules/@oclif/core/lib/errors/errors/pretty-print.js

@@ -0,0 +1,51 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyPrettyPrintOptions = applyPrettyPrintOptions;
+exports.default = prettyPrint;
+const indent_string_1 = __importDefault(require("indent-string"));
+const wrap_ansi_1 = __importDefault(require("wrap-ansi"));
+const screen_1 = require("../../screen");
+const settings_1 = require("../../settings");
+function applyPrettyPrintOptions(error, options) {
+    const prettyErrorKeys = ['message', 'code', 'ref', 'suggestions'];
+    for (const key of prettyErrorKeys) {
+        const applyOptionsKey = !(key in error) && options[key];
+        if (applyOptionsKey) {
+            ;
+            error[key] = options[key];
+        }
+    }
+    return error;
+}
+const formatSuggestions = (suggestions) => {
+    const label = 'Try this:';
+    if (!suggestions || suggestions.length === 0)
+        return undefined;
+    if (suggestions.length === 1)
+        return `${label} ${suggestions[0]}`;
+    const multiple = suggestions.map((suggestion) => `* ${suggestion}`).join('\n');
+    return `${label}\n${(0, indent_string_1.default)(multiple, 2)}`;
+};
+function prettyPrint(error) {
+    if (settings_1.settings.debug) {
+        return error.stack;
+    }
+    const { bang, code, message, name: errorSuffix, ref, suggestions } = error;
+    // errorSuffix is pulled from the 'name' property on CLIError
+    // and is like either Error or Warning
+    const formattedHeader = message ? `${errorSuffix || 'Error'}: ${message}` : undefined;
+    const formattedCode = code ? `Code: ${code}` : undefined;
+    const formattedSuggestions = formatSuggestions(suggestions);
+    const formattedReference = ref ? `Reference: ${ref}` : undefined;
+    const formatted = [formattedHeader, formattedCode, formattedSuggestions, formattedReference]
+        .filter(Boolean)
+        .join('\n');
+    let output = (0, wrap_ansi_1.default)(formatted, screen_1.errtermwidth - 6, { hard: true, trim: false });
+    output = (0, indent_string_1.default)(output, 3);
+    output = (0, indent_string_1.default)(output, 1, { includeEmptyLines: true, indent: bang || '' });
+    output = (0, indent_string_1.default)(output, 1);
+    return output;
+}

node_modules/@oclif/core/lib/errors/exit.d.ts

@@ -0,0 +1 @@
+export declare function exit(code?: number): never;

node_modules/@oclif/core/lib/errors/exit.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exit = exit;
+const exit_1 = require("./errors/exit");
+function exit(code = 0) {
+    throw new exit_1.ExitError(code);
+}

node_modules/@oclif/core/lib/errors/handle.d.ts

@@ -0,0 +1,14 @@
+import { OclifError, PrettyPrintableError } from '../interfaces';
+import { CLIParseError } from '../parser/errors';
+import { CLIError } from './errors/cli';
+/**
+ * This is an odd abstraction for process.exit, but it allows us to stub it in tests.
+ *
+ * https://github.com/sinonjs/sinon/issues/562
+ */
+export declare const Exit: {
+    exit(code?: number): never;
+};
+type ErrorToHandle = Error & Partial<PrettyPrintableError> & Partial<OclifError> & Partial<CLIError> & Partial<CLIParseError>;
+export declare function handle(err: ErrorToHandle): Promise<void>;
+export {};

node_modules/@oclif/core/lib/errors/handle.js

@@ -0,0 +1,60 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Exit = void 0;
+exports.handle = handle;
+const clean_stack_1 = __importDefault(require("clean-stack"));
+const cache_1 = __importDefault(require("../cache"));
+const index_1 = require("../help/index");
+const logger_1 = require("../logger");
+const cli_1 = require("./errors/cli");
+const exit_1 = require("./errors/exit");
+const pretty_print_1 = __importDefault(require("./errors/pretty-print"));
+/**
+ * This is an odd abstraction for process.exit, but it allows us to stub it in tests.
+ *
+ * https://github.com/sinonjs/sinon/issues/562
+ */
+exports.Exit = {
+    exit(code = 0) {
+        // eslint-disable-next-line n/no-process-exit, unicorn/no-process-exit
+        process.exit(code);
+    },
+};
+async function handle(err) {
+    try {
+        if (!err)
+            err = new cli_1.CLIError('no error?');
+        if (err.message === 'SIGINT')
+            exports.Exit.exit(1);
+        const shouldPrint = !(err instanceof exit_1.ExitError) && !err.skipOclifErrorHandling;
+        const pretty = (0, pretty_print_1.default)(err);
+        const stack = (0, clean_stack_1.default)(err.stack || '', { pretty: true });
+        if (shouldPrint) {
+            console.error(pretty ?? stack);
+            const config = cache_1.default.getInstance().get('config');
+            if (err.showHelp && err.parse?.input?.argv && config) {
+                const options = {
+                    ...(config.pjson.oclif.helpOptions ?? config.pjson.helpOptions),
+                    sections: ['flags', 'usage', 'arguments'],
+                    sendToStderr: true,
+                };
+                const help = new index_1.Help(config, options);
+                console.error();
+                await help.showHelp(process.argv.slice(2));
+            }
+        }
+        const exitCode = err.oclif?.exit ?? 1;
+        if (err.code !== 'EEXIT' && stack) {
+            (0, logger_1.getLogger)().error(stack);
+        }
+        exports.Exit.exit(exitCode);
+    }
+    catch (error) {
+        console.error(err.stack);
+        console.error(error.stack);
+        exports.Exit.exit(1);
+    }
+}

node_modules/@oclif/core/lib/errors/index.d.ts

@@ -0,0 +1,8 @@
+export { PrettyPrintableError } from '../interfaces';
+export { error } from './error';
+export { CLIError } from './errors/cli';
+export { ExitError } from './errors/exit';
+export { ModuleLoadError } from './errors/module-load';
+export { exit } from './exit';
+export { handle } from './handle';
+export { warn } from './warn';

node_modules/@oclif/core/lib/errors/index.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.warn = exports.handle = exports.exit = exports.ModuleLoadError = exports.ExitError = exports.CLIError = exports.error = void 0;
+var error_1 = require("./error");
+Object.defineProperty(exports, "error", { enumerable: true, get: function () { return error_1.error; } });
+var cli_1 = require("./errors/cli");
+Object.defineProperty(exports, "CLIError", { enumerable: true, get: function () { return cli_1.CLIError; } });
+var exit_1 = require("./errors/exit");
+Object.defineProperty(exports, "ExitError", { enumerable: true, get: function () { return exit_1.ExitError; } });
+var module_load_1 = require("./errors/module-load");
+Object.defineProperty(exports, "ModuleLoadError", { enumerable: true, get: function () { return module_load_1.ModuleLoadError; } });
+var exit_2 = require("./exit");
+Object.defineProperty(exports, "exit", { enumerable: true, get: function () { return exit_2.exit; } });
+var handle_1 = require("./handle");
+Object.defineProperty(exports, "handle", { enumerable: true, get: function () { return handle_1.handle; } });
+var warn_1 = require("./warn");
+Object.defineProperty(exports, "warn", { enumerable: true, get: function () { return warn_1.warn; } });

node_modules/@oclif/core/lib/errors/warn.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Prints a pretty warning message to stderr.
+ *
+ * @param input The error or string to print.
+ */
+export declare function warn(input: Error | string): void;
+export declare function memoizedWarn(input: Error | string): void;
+export default warn;

node_modules/@oclif/core/lib/errors/warn.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.warn = warn;
+exports.memoizedWarn = memoizedWarn;
+const logger_1 = require("../logger");
+const write_1 = require("../ux/write");
+const cli_1 = require("./errors/cli");
+const pretty_print_1 = __importDefault(require("./errors/pretty-print"));
+/**
+ * Prints a pretty warning message to stderr.
+ *
+ * @param input The error or string to print.
+ */
+function warn(input) {
+    let err;
+    if (typeof input === 'string') {
+        err = new cli_1.CLIError.Warn(input);
+    }
+    else if (input instanceof Error) {
+        err = (0, cli_1.addOclifExitCode)(input);
+    }
+    else {
+        throw new TypeError('first argument must be a string or instance of Error');
+    }
+    const message = (0, pretty_print_1.default)(err);
+    if (message)
+        (0, write_1.stderr)(message);
+    if (err?.stack)
+        (0, logger_1.getLogger)().error(err.stack);
+}
+const WARNINGS = new Set();
+function memoizedWarn(input) {
+    if (!WARNINGS.has(input))
+        warn(input);
+    WARNINGS.add(input);
+}
+exports.default = warn;

node_modules/@oclif/core/lib/execute.d.ts

@@ -0,0 +1,44 @@
+import { LoadOptions } from './interfaces';
+/**
+ * Load and run oclif CLI
+ *
+ * @example For ESM dev.js
+ * ```
+ * #!/usr/bin/env -S node --loader ts-node/esm --no-warnings=ExperimentalWarning
+ * import { execute } from '@oclif/core'
+ *
+ * await execute({development: true, dir: import.meta.url})
+ * ```
+ *
+ * @example For ESM run.js
+ * ```
+ * #!/usr/bin/env node
+ * import { execute } from '@oclif/core'
+ *
+ * await execute({dir: import.meta.url})
+ * ```
+ *
+ * @example For CJS dev.js
+ * ```
+ * #!/usr/bin/env ts-node
+ * void (async () => {
+ *   const oclif = await import('@oclif/core')
+ *   await oclif.execute({development: true, dir: __dirname})
+ * })()
+ * ```
+ *
+ * @example For CJS run.js
+ * ```
+ * #!/usr/bin/env node
+ * void (async () => {
+ *   const oclif = await import('@oclif/core')
+ *   await oclif.execute({dir: __dirname})
+ * })()
+ * ```
+ */
+export declare function execute(options: {
+    args?: string[];
+    development?: boolean;
+    dir?: string;
+    loadOptions?: LoadOptions;
+}): Promise<unknown>;

node_modules/@oclif/core/lib/execute.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.execute = execute;
+const errors_1 = require("./errors");
+const handle_1 = require("./errors/handle");
+const flush_1 = require("./flush");
+const main_1 = require("./main");
+const settings_1 = require("./settings");
+/**
+ * Load and run oclif CLI
+ *
+ * @example For ESM dev.js
+ * ```
+ * #!/usr/bin/env -S node --loader ts-node/esm --no-warnings=ExperimentalWarning
+ * import { execute } from '@oclif/core'
+ *
+ * await execute({development: true, dir: import.meta.url})
+ * ```
+ *
+ * @example For ESM run.js
+ * ```
+ * #!/usr/bin/env node
+ * import { execute } from '@oclif/core'
+ *
+ * await execute({dir: import.meta.url})
+ * ```
+ *
+ * @example For CJS dev.js
+ * ```
+ * #!/usr/bin/env ts-node
+ * void (async () => {
+ *   const oclif = await import('@oclif/core')
+ *   await oclif.execute({development: true, dir: __dirname})
+ * })()
+ * ```
+ *
+ * @example For CJS run.js
+ * ```
+ * #!/usr/bin/env node
+ * void (async () => {
+ *   const oclif = await import('@oclif/core')
+ *   await oclif.execute({dir: __dirname})
+ * })()
+ * ```
+ */
+async function execute(options) {
+    if (!options.dir && !options.loadOptions) {
+        throw new errors_1.CLIError('dir or loadOptions is required.');
+    }
+    if (options.development) {
+        // In dev mode -> use ts-node and dev plugins
+        process.env.NODE_ENV = 'development';
+        settings_1.settings.debug = true;
+    }
+    return (0, main_1.run)(options.args ?? process.argv.slice(2), options.loadOptions ?? options.dir)
+        .then(async (result) => {
+        (0, flush_1.flush)();
+        return result;
+    })
+        .catch(async (error) => (0, handle_1.handle)(error));
+}

node_modules/@oclif/core/lib/flags.d.ts

@@ -0,0 +1,181 @@
+import { URL } from 'node:url';
+import { BooleanFlag, CustomOptions, FlagDefinition, OptionFlag } from './interfaces';
+type NotArray<T> = T extends Array<any> ? never : T;
+/**
+ * Create a custom flag.
+ *
+ * @example
+ * type Id = string
+ * type IdOpts = { startsWith: string; length: number }
+ *
+ * export const myFlag = custom<Id, IdOpts>({
+ *   parse: async (input, opts) => {
+ *     if (input.startsWith(opts.startsWith) && input.length === opts.length) {
+ *       return input
+ *     }
+ *
+ *     throw new Error('Invalid id')
+ *   },
+ * })
+ */
+export declare function custom<T = string, P extends CustomOptions = CustomOptions>(defaults: Partial<OptionFlag<T[], P>> & {
+    multiple: true;
+} & ({
+    default: OptionFlag<T[], P>['default'];
+} | {
+    required: true;
+})): FlagDefinition<T, P, {
+    multiple: true;
+    requiredOrDefaulted: true;
+}>;
+export declare function custom<T = string, P extends CustomOptions = CustomOptions>(defaults: Partial<OptionFlag<NotArray<T>, P>> & {
+    multiple?: false | undefined;
+} & ({
+    default: OptionFlag<NotArray<T>, P>['default'];
+} | {
+    required: true;
+})): FlagDefinition<T, P, {
+    multiple: false;
+    requiredOrDefaulted: true;
+}>;
+export declare function custom<T = string, P extends CustomOptions = CustomOptions>(defaults: Partial<OptionFlag<NotArray<T>, P>> & {
+    default?: OptionFlag<NotArray<T>, P>['default'] | undefined;
+    multiple?: false | undefined;
+    required?: false | undefined;
+}): FlagDefinition<T, P, {
+    multiple: false;
+    requiredOrDefaulted: false;
+}>;
+export declare function custom<T = string, P extends CustomOptions = CustomOptions>(defaults: Partial<OptionFlag<T[], P>> & {
+    default?: OptionFlag<T[], P>['default'] | undefined;
+    multiple: true;
+    required?: false | undefined;
+}): FlagDefinition<T, P, {
+    multiple: true;
+    requiredOrDefaulted: false;
+}>;
+export declare function custom<T = string, P extends CustomOptions = CustomOptions>(): FlagDefinition<T, P, {
+    multiple: false;
+    requiredOrDefaulted: false;
+}>;
+/**
+ * A boolean flag. Defaults to `false` unless default is set to `true`.
+ *
+ * - `allowNo` option allows `--no-` prefix to negate boolean flag.
+ */
+export declare function boolean<T = boolean>(options?: Partial<BooleanFlag<T>>): BooleanFlag<T>;
+/**
+ * An integer flag. Throws an error if the provided value is not a valid integer.
+ *
+ * - `min` option allows to set a minimum value.
+ * - `max` option allows to set a maximum value.
+ */
+export declare const integer: FlagDefinition<number, {
+    max?: number;
+    min?: number;
+}, {
+    multiple: false;
+    requiredOrDefaulted: false;
+}>;
+/**
+ * A directory flag.
+ *
+ * - `exists` option allows you to throw an error if the directory does not exist.
+ */
+export declare const directory: FlagDefinition<string, {
+    exists?: boolean;
+}, {
+    multiple: false;
+    requiredOrDefaulted: false;
+}>;
+/**
+ * A file flag.
+ *
+ * - `exists` option allows you to throw an error if the file does not exist.
+ */
+export declare const file: FlagDefinition<string, {
+    exists?: boolean;
+}, {
+    multiple: false;
+    requiredOrDefaulted: false;
+}>;
+/**
+ * A URL flag that converts the provided value is a string.
+ *
+ * Throws an error if the string is not a valid URL.
+ */
+export declare const url: FlagDefinition<URL, CustomOptions, {
+    multiple: false;
+    requiredOrDefaulted: false;
+}>;
+/**
+ * A string flag.
+ */
+export declare const string: FlagDefinition<string, CustomOptions, {
+    multiple: false;
+    requiredOrDefaulted: false;
+}>;
+/**
+ * Version flag that will print the CLI version and exit.
+ */
+export declare const version: (opts?: Partial<BooleanFlag<boolean>>) => BooleanFlag<void>;
+/**
+ * A help flag that will print the CLI help and exit.
+ */
+export declare const help: (opts?: Partial<BooleanFlag<boolean>>) => BooleanFlag<void>;
+type ReadonlyElementOf<T extends ReadonlyArray<unknown>> = T[number];
+/**
+ * Create a custom flag that infers the flag type from the provided options.
+ *
+ * The provided `options` must be a readonly array in order for type inference to work.
+ *
+ * @example
+ * export default class MyCommand extends Command {
+ *   static flags = {
+ *     name: Flags.option({
+ *       options: ['foo', 'bar'] as const,
+ *     })(),
+ *   }
+ * }
+ */
+export declare function option<T extends readonly string[], P extends CustomOptions>(defaults: Partial<OptionFlag<ReadonlyElementOf<T>[], P>> & {
+    multiple: true;
+    options: T;
+} & ({
+    default: OptionFlag<ReadonlyElementOf<T>[], P>['default'] | undefined;
+} | {
+    required: true;
+})): FlagDefinition<(typeof defaults.options)[number], P, {
+    multiple: true;
+    requiredOrDefaulted: true;
+}>;
+export declare function option<T extends readonly string[], P extends CustomOptions>(defaults: Partial<OptionFlag<ReadonlyElementOf<T>, P>> & {
+    multiple?: false | undefined;
+    options: T;
+} & ({
+    default: OptionFlag<ReadonlyElementOf<T>, P>['default'];
+} | {
+    required: true;
+})): FlagDefinition<(typeof defaults.options)[number], P, {
+    multiple: false;
+    requiredOrDefaulted: true;
+}>;
+export declare function option<T extends readonly string[], P extends CustomOptions>(defaults: Partial<OptionFlag<ReadonlyElementOf<T>, P>> & {
+    default?: OptionFlag<ReadonlyElementOf<T>, P>['default'] | undefined;
+    multiple?: false | undefined;
+    options: T;
+    required?: false | undefined;
+}): FlagDefinition<(typeof defaults.options)[number], P, {
+    multiple: false;
+    requiredOrDefaulted: false;
+}>;
+export declare function option<T extends readonly string[], P extends CustomOptions>(defaults: Partial<OptionFlag<ReadonlyElementOf<T>[], P>> & {
+    default?: OptionFlag<ReadonlyElementOf<T>[], P>['default'] | undefined;
+    multiple: true;
+    options: T;
+    required?: false | undefined;
+}): FlagDefinition<(typeof defaults.options)[number], P, {
+    multiple: true;
+    requiredOrDefaulted: false;
+}>;
+export {};

node_modules/@oclif/core/lib/flags.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.help = exports.version = exports.string = exports.url = exports.file = exports.directory = exports.integer = void 0;
+exports.custom = custom;
+exports.boolean = boolean;
+exports.option = option;
+const node_url_1 = require("node:url");
+const errors_1 = require("./errors");
+const help_1 = require("./help");
+const fs_1 = require("./util/fs");
+function custom(defaults) {
+    return (options = {}) => ({
+        parse: async (input, _ctx, _opts) => input,
+        ...defaults,
+        ...options,
+        input: [],
+        multiple: Boolean(options.multiple === undefined ? (defaults?.multiple ?? false) : options.multiple),
+        type: 'option',
+    });
+}
+/**
+ * A boolean flag. Defaults to `false` unless default is set to `true`.
+ *
+ * - `allowNo` option allows `--no-` prefix to negate boolean flag.
+ */
+function boolean(options = {}) {
+    return {
+        parse: async (b, _) => b,
+        ...options,
+        allowNo: Boolean(options.allowNo),
+        type: 'boolean',
+    };
+}
+/**
+ * An integer flag. Throws an error if the provided value is not a valid integer.
+ *
+ * - `min` option allows to set a minimum value.
+ * - `max` option allows to set a maximum value.
+ */
+exports.integer = custom({
+    async parse(input, _, opts) {
+        if (!/^-?\d+$/.test(input))
+            throw new errors_1.CLIError(`Expected an integer but received: ${input}`);
+        const num = Number.parseInt(input, 10);
+        if (opts.min !== undefined && num < opts.min)
+            throw new errors_1.CLIError(`Expected an integer greater than or equal to ${opts.min} but received: ${input}`);
+        if (opts.max !== undefined && num > opts.max)
+            throw new errors_1.CLIError(`Expected an integer less than or equal to ${opts.max} but received: ${input}`);
+        return num;
+    },
+});
+/**
+ * A directory flag.
+ *
+ * - `exists` option allows you to throw an error if the directory does not exist.
+ */
+exports.directory = custom({
+    async parse(input, _, opts) {
+        if (opts.exists)
+            return (0, fs_1.dirExists)(input);
+        return input;
+    },
+});
+/**
+ * A file flag.
+ *
+ * - `exists` option allows you to throw an error if the file does not exist.
+ */
+exports.file = custom({
+    async parse(input, _, opts) {
+        if (opts.exists)
+            return (0, fs_1.fileExists)(input);
+        return input;
+    },
+});
+/**
+ * A URL flag that converts the provided value is a string.
+ *
+ * Throws an error if the string is not a valid URL.
+ */
+exports.url = custom({
+    async parse(input) {
+        try {
+            return new node_url_1.URL(input);
+        }
+        catch {
+            throw new errors_1.CLIError(`Expected a valid url but received: ${input}`);
+        }
+    },
+});
+/**
+ * A string flag.
+ */
+exports.string = custom();
+/**
+ * Version flag that will print the CLI version and exit.
+ */
+const version = (opts = {}) => boolean({
+    description: 'Show CLI version.',
+    ...opts,
+    async parse(_, ctx) {
+        ctx.log(ctx.config.userAgent);
+        ctx.exit(0);
+    },
+});
+exports.version = version;
+/**
+ * A help flag that will print the CLI help and exit.
+ */
+const help = (opts = {}) => boolean({
+    description: 'Show CLI help.',
+    ...opts,
+    async parse(_, cmd) {
+        const Help = await (0, help_1.loadHelpClass)(cmd.config);
+        await new Help(cmd.config, cmd.config.pjson.oclif.helpOptions ?? cmd.config.pjson.helpOptions).showHelp(cmd.id ? [cmd.id, ...cmd.argv] : cmd.argv);
+        cmd.exit(0);
+    },
+});
+exports.help = help;
+function option(defaults) {
+    return (options = {}) => ({
+        parse: async (input, _ctx, _opts) => input,
+        ...defaults,
+        ...options,
+        input: [],
+        multiple: Boolean(options.multiple === undefined ? defaults.multiple : options.multiple),
+        type: 'option',
+    });
+}

node_modules/@oclif/core/lib/flush.d.ts

@@ -0,0 +1 @@
+export declare function flush(ms?: number): Promise<void>;

node_modules/@oclif/core/lib/flush.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flush = flush;
+const error_1 = require("./errors/error");
+function timeout(p, ms) {
+    function wait(ms, unref = false) {
+        return new Promise((resolve) => {
+            const t = setTimeout(() => resolve(null), ms);
+            if (unref)
+                t.unref();
+        });
+    }
+    return Promise.race([p, wait(ms, true).then(() => (0, error_1.error)('timed out'))]);
+}
+async function _flush() {
+    const p = new Promise((resolve) => {
+        process.stdout.once('drain', () => resolve(null));
+    });
+    const flushed = process.stdout.write('');
+    if (flushed)
+        return;
+    return p;
+}
+async function flush(ms = 10_000) {
+    await timeout(_flush(), ms);
+}

node_modules/@oclif/core/lib/help/command.d.ts

@@ -0,0 +1,33 @@
+import { Command } from '../command';
+import * as Interfaces from '../interfaces';
+import { HelpFormatter, HelpSectionRenderer } from './formatter';
+export declare class CommandHelp extends HelpFormatter {
+    command: Command.Loadable;
+    config: Interfaces.Config;
+    opts: Interfaces.HelpOptions;
+    constructor(command: Command.Loadable, config: Interfaces.Config, opts: Interfaces.HelpOptions);
+    protected aliases(aliases: string[] | undefined): string | undefined;
+    protected arg(arg: Command.Arg.Any): string;
+    protected args(args: Command.Arg.Any[]): [string, string | undefined][] | undefined;
+    protected defaultUsage(): string;
+    protected description(): string | undefined;
+    protected examples(examples: Command.Example[] | string | undefined): string | undefined;
+    protected flagHelpLabel(flag: Command.Flag.Any, showOptions?: boolean): string;
+    protected flags(flags: Array<Command.Flag.Any>): [string, string | undefined][] | undefined;
+    protected flagsDescriptions(flags: Array<Command.Flag.Any>): string | undefined;
+    generate(): string;
+    protected groupFlags(flags: Array<Command.Flag.Any>): {
+        flagGroups: {
+            [name: string]: Array<Command.Flag.Any>;
+        };
+        mainFlags: Array<Command.Flag.Any>;
+    };
+    protected sections(): Array<{
+        generate: HelpSectionRenderer;
+        header: string;
+    }>;
+    protected usage(): string;
+    private formatIfCommand;
+    private isCommand;
+}
+export default CommandHelp;

node_modules/@oclif/core/lib/help/command.js

@@ -0,0 +1,338 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandHelp = void 0;
+const ansis_1 = __importDefault(require("ansis"));
+const ensure_arg_object_1 = require("../util/ensure-arg-object");
+const ids_1 = require("../util/ids");
+const util_1 = require("../util/util");
+const theme_1 = require("../ux/theme");
+const docopts_1 = require("./docopts");
+const formatter_1 = require("./formatter");
+// Don't use os.EOL because we need to ensure that a string
+// written on any platform, that may use \r\n or \n, will be
+// split on any platform, not just the os specific EOL at runtime.
+const POSSIBLE_LINE_FEED = /\r\n|\n/;
+/**
+ * Determines the sort order of flags. Will default to alphabetical if not set or set to an invalid value.
+ */
+function determineSortOrder(flagSortOrder) {
+    if (flagSortOrder === 'alphabetical')
+        return 'alphabetical';
+    if (flagSortOrder === 'none')
+        return 'none';
+    return 'alphabetical';
+}
+class CommandHelp extends formatter_1.HelpFormatter {
+    command;
+    config;
+    opts;
+    constructor(command, config, opts) {
+        super(config, opts);
+        this.command = command;
+        this.config = config;
+        this.opts = opts;
+    }
+    aliases(aliases) {
+        if (!aliases || aliases.length === 0)
+            return;
+        const body = aliases
+            .map((a) => [
+            (0, theme_1.colorize)(this.config?.theme?.dollarSign, '$'),
+            (0, theme_1.colorize)(this.config?.theme?.bin, this.config.bin),
+            (0, theme_1.colorize)(this.config?.theme?.alias, a),
+        ].join(' '))
+            .join('\n');
+        return body;
+    }
+    arg(arg) {
+        const name = arg.name.toUpperCase();
+        if (arg.required)
+            return `${name}`;
+        return `[${name}]`;
+    }
+    args(args) {
+        if (args.filter((a) => a.description).length === 0)
+            return;
+        return args.map((a) => {
+            // Add ellipsis to indicate that the argument takes multiple values if strict is false
+            let name = this.command.strict === false ? `${a.name.toUpperCase()}...` : a.name.toUpperCase();
+            name = a.required ? `${name}` : `[${name}]`;
+            let description = a.description || '';
+            if (a.default)
+                description = `${(0, theme_1.colorize)(this.config?.theme?.flagDefaultValue, `[default: ${a.default}]`)} ${description}`;
+            if (a.options)
+                description = `${(0, theme_1.colorize)(this.config?.theme?.flagOptions, `(${a.options.join('|')})`)} ${description}`;
+            return [
+                (0, theme_1.colorize)(this.config?.theme?.flag, name),
+                description ? (0, theme_1.colorize)(this.config?.theme?.sectionDescription, description) : undefined,
+            ];
+        });
+    }
+    defaultUsage() {
+        // Docopts by default
+        if (this.opts.docopts === undefined || this.opts.docopts) {
+            return docopts_1.DocOpts.generate(this.command);
+        }
+        return (0, util_1.compact)([
+            this.command.id,
+            Object.values(this.command.args ?? {})
+                ?.filter((a) => !a.hidden)
+                .map((a) => this.arg(a))
+                .join(' '),
+        ]).join(' ');
+    }
+    description() {
+        const cmd = this.command;
+        let description;
+        if (this.opts.hideCommandSummaryInDescription) {
+            description = [(cmd.description || '').split(POSSIBLE_LINE_FEED).at(-1) ?? ''];
+        }
+        else if (cmd.description) {
+            const summary = cmd.summary ? `${cmd.summary}\n` : null;
+            description = summary
+                ? [...summary.split(POSSIBLE_LINE_FEED), ...(cmd.description || '').split(POSSIBLE_LINE_FEED)]
+                : (cmd.description || '').split(POSSIBLE_LINE_FEED);
+        }
+        if (description) {
+            return this.wrap(description.join('\n'));
+        }
+    }
+    examples(examples) {
+        if (!examples || examples.length === 0)
+            return;
+        const body = (0, util_1.castArray)(examples)
+            .map((a) => {
+            let description;
+            let commands;
+            if (typeof a === 'string') {
+                const lines = a.split(POSSIBLE_LINE_FEED).filter(Boolean);
+                // If the example is <description>\n<command> then format correctly
+                if (lines.length >= 2 && !this.isCommand(lines[0]) && lines.slice(1).every((i) => this.isCommand(i))) {
+                    description = lines[0];
+                    commands = lines.slice(1);
+                }
+                else {
+                    return lines.map((line) => this.formatIfCommand(line)).join('\n');
+                }
+            }
+            else {
+                description = a.description;
+                commands = [a.command];
+            }
+            const multilineSeparator = this.config.platform === 'win32' ? (this.config.shell.includes('powershell') ? '`' : '^') : '\\';
+            // The command will be indented in the section, which is also indented
+            const finalIndentedSpacing = this.indentSpacing * 2;
+            const multilineCommands = commands
+                .map((c) => 
+            // First indent keeping room for escaped newlines
+            this.indent(this.wrap(this.formatIfCommand(c), finalIndentedSpacing + 4))
+                // Then add the escaped newline
+                .split(POSSIBLE_LINE_FEED)
+                .join(` ${multilineSeparator}\n  `))
+                .join('\n');
+            return `${this.wrap(description, finalIndentedSpacing)}\n\n${multilineCommands}`;
+        })
+            .join('\n\n');
+        return body;
+    }
+    flagHelpLabel(flag, showOptions = false) {
+        let label = flag.helpLabel;
+        if (!label) {
+            const labels = [];
+            labels.push(flag.char ? `-${flag.char[0]}` : '  ');
+            if (flag.name) {
+                if (flag.type === 'boolean' && flag.allowNo) {
+                    labels.push(`--[no-]${flag.name.trim()}`);
+                }
+                else {
+                    labels.push(`--${flag.name.trim()}`);
+                }
+            }
+            label = labels.join(flag.char ? (0, theme_1.colorize)(this.config?.theme?.flagSeparator, ', ') : '  ');
+        }
+        if (flag.type === 'option') {
+            let value = docopts_1.DocOpts.formatUsageType(flag, this.opts.showFlagNameInTitle ?? false, this.opts.showFlagOptionsInTitle ?? showOptions);
+            if (!value.includes('|'))
+                value = (0, theme_1.colorize)('underline', value);
+            label += `=${value}`;
+        }
+        return (0, theme_1.colorize)(this.config.theme?.flag, label);
+    }
+    flags(flags) {
+        if (flags.length === 0)
+            return;
+        const noChar = flags.reduce((previous, current) => previous && current.char === undefined, true);
+        // eslint-disable-next-line complexity
+        return flags.map((flag) => {
+            let left = this.flagHelpLabel(flag);
+            if (noChar)
+                left = left.replace('    ', '');
+            let right = flag.summary || flag.description || '';
+            const canBeCached = !(this.opts.respectNoCacheDefault === true && flag.noCacheDefault === true);
+            if (flag.type === 'option' && flag.default && canBeCached) {
+                right = `${(0, theme_1.colorize)(this.config?.theme?.flagDefaultValue, `[default: ${flag.default}]`)} ${right}`;
+            }
+            if (flag.required)
+                right = `${(0, theme_1.colorize)(this.config?.theme?.flagRequired, '(required)')} ${right}`;
+            if (flag.type === 'option' && flag.options && !flag.helpValue && !this.opts.showFlagOptionsInTitle) {
+                right += (0, theme_1.colorize)(this.config?.theme?.flagOptions, `\n<options: ${flag.options.join('|')}>`);
+            }
+            return [left, (0, theme_1.colorize)(this.config?.theme?.sectionDescription, right.trim())];
+        });
+    }
+    flagsDescriptions(flags) {
+        const flagsWithExtendedDescriptions = flags.filter((flag) => flag.summary && flag.description);
+        if (flagsWithExtendedDescriptions.length === 0)
+            return;
+        const body = flagsWithExtendedDescriptions
+            .map((flag) => {
+            // Guaranteed to be set because of the filter above, but make ts happy
+            const summary = flag.summary || '';
+            let flagHelp = this.flagHelpLabel(flag, true);
+            if (!flag.char)
+                flagHelp = flagHelp.replace('    ', '');
+            flagHelp +=
+                flagHelp.length + summary.length + 2 < this.opts.maxWidth
+                    ? '  ' + summary
+                    : '\n\n' + this.indent(this.wrap(summary, this.indentSpacing * 2));
+            return `${flagHelp}\n\n${this.indent(this.wrap(flag.description || '', this.indentSpacing * 2))}`;
+        })
+            .join('\n\n');
+        return body;
+    }
+    generate() {
+        const cmd = this.command;
+        const unsortedFlags = Object.entries(cmd.flags || {})
+            .filter(([, v]) => !v.hidden)
+            .map(([k, v]) => {
+            v.name = k;
+            return v;
+        });
+        const flags = determineSortOrder(this.opts.flagSortOrder) === 'alphabetical'
+            ? (0, util_1.sortBy)(unsortedFlags, (f) => [!f.char, f.char, f.name])
+            : unsortedFlags;
+        const args = Object.values((0, ensure_arg_object_1.ensureArgObject)(cmd.args)).filter((a) => !a.hidden);
+        const output = (0, util_1.compact)(this.sections().map(({ generate, header }) => {
+            const body = generate({ args, cmd, flags }, header);
+            // Generate can return a list of sections
+            if (Array.isArray(body)) {
+                return body
+                    .map((helpSection) => helpSection && helpSection.body && this.section(helpSection.header, helpSection.body))
+                    .join('\n\n');
+            }
+            return body && this.section(header, body);
+        })).join('\n\n');
+        return output;
+    }
+    groupFlags(flags) {
+        const mainFlags = [];
+        const flagGroups = {};
+        for (const flag of flags) {
+            const group = flag.helpGroup;
+            if (group) {
+                if (!flagGroups[group])
+                    flagGroups[group] = [];
+                flagGroups[group].push(flag);
+            }
+            else {
+                mainFlags.push(flag);
+            }
+        }
+        return { flagGroups, mainFlags };
+    }
+    sections() {
+        const sections = [
+            {
+                generate: () => this.usage(),
+                header: this.opts.usageHeader || 'USAGE',
+            },
+            {
+                generate: ({ args }, header) => [{ body: this.args(args), header }],
+                header: 'ARGUMENTS',
+            },
+            {
+                generate: ({ flags }, header) => {
+                    const { flagGroups, mainFlags } = this.groupFlags(flags);
+                    const flagSections = [];
+                    const mainFlagBody = this.flags(mainFlags);
+                    if (mainFlagBody)
+                        flagSections.push({ body: mainFlagBody, header });
+                    for (const [name, flags] of Object.entries(flagGroups)) {
+                        const body = this.flags(flags);
+                        if (body)
+                            flagSections.push({ body, header: `${name.toUpperCase()} ${header}` });
+                    }
+                    return (0, util_1.compact)(flagSections);
+                },
+                header: 'FLAGS',
+            },
+            {
+                generate: () => this.description(),
+                header: 'DESCRIPTION',
+            },
+            {
+                generate: ({ cmd }) => this.aliases(cmd.aliases),
+                header: 'ALIASES',
+            },
+            {
+                generate: ({ cmd }) => {
+                    const examples = cmd.examples || cmd.example;
+                    return this.examples(examples);
+                },
+                header: 'EXAMPLES',
+            },
+            {
+                generate: ({ flags }) => this.flagsDescriptions(flags),
+                header: 'FLAG DESCRIPTIONS',
+            },
+        ];
+        const allowedSections = this.opts.sections?.map((s) => s.toLowerCase());
+        return sections.filter(({ header }) => !allowedSections || allowedSections.includes(header.toLowerCase()));
+    }
+    usage() {
+        const { id, usage } = this.command;
+        const standardId = (0, ids_1.toStandardizedId)(id, this.config);
+        const configuredId = (0, ids_1.toConfiguredId)(id, this.config);
+        const body = (usage ? (0, util_1.castArray)(usage) : [this.defaultUsage()])
+            .map((u) => {
+            const allowedSpacing = this.opts.maxWidth - this.indentSpacing;
+            const dollarSign = (0, theme_1.colorize)(this.config?.theme?.dollarSign, '$');
+            const bin = (0, theme_1.colorize)(this.config?.theme?.bin, this.config.bin);
+            const command = (0, theme_1.colorize)(this.config?.theme?.command, '<%= command.id %>');
+            const commandDescription = (0, theme_1.colorize)(this.config?.theme?.sectionDescription, u
+                .replace('<%= command.id %>', '')
+                .replace(new RegExp(`^${standardId}`), '')
+                .replace(new RegExp(`^${configuredId}`), '')
+                .trim());
+            const line = `${dollarSign} ${bin} ${command} ${commandDescription}`.trim();
+            if (line.length > allowedSpacing) {
+                const splitIndex = line.slice(0, Math.max(0, allowedSpacing)).lastIndexOf(' ');
+                return (line.slice(0, Math.max(0, splitIndex)) +
+                    '\n' +
+                    this.indent(this.wrap(line.slice(Math.max(0, splitIndex)), this.indentSpacing * 2)));
+            }
+            return this.wrap(line);
+        })
+            .join('\n');
+        return body;
+    }
+    formatIfCommand(example) {
+        example = this.render(example);
+        const dollarSign = (0, theme_1.colorize)(this.config?.theme?.dollarSign, '$');
+        if (example.startsWith(this.config.bin))
+            return `${dollarSign} ${example}`;
+        if (example.startsWith(`$ ${this.config.bin}`))
+            return `${dollarSign}${example.replace(`$`, '')}`;
+        return example;
+    }
+    isCommand(example) {
+        return ansis_1.default
+            .strip(this.formatIfCommand(example))
+            .startsWith(`${(0, theme_1.colorize)(this.config?.theme?.dollarSign, '$')} ${this.config.bin}`);
+    }
+}
+exports.CommandHelp = CommandHelp;
+exports.default = CommandHelp;

node_modules/@oclif/core/lib/help/docopts.d.ts

@@ -0,0 +1,69 @@
+import { Command } from '../command';
+/**
+ * DocOpts - See http://docopt.org/.
+ *
+ * flag.exclusive: groups elements when one of the mutually exclusive cases is a required flag: (--apple | --orange)
+ * flag.exclusive: groups elements when none of the mutually exclusive cases is required (optional flags): [--apple | --orange]
+ * flag.dependsOn: specifies that if one element is present, then another one is required: (--apple --orange)
+ *
+ * @example
+ *  {
+ *      name: 'classnames',
+ *      required: true,
+ *      exclusive: ['suitenames']
+ *      ...
+ *  },{
+ *      name: 'suitenames',
+ *      type: 'array'
+ *      required: true
+ *      ...
+ *  }
+ *
+ *  Results in:
+ *      Usage: <%= command.id %> (-n <string> | -s <array>)
+ *
+ * @example
+ *  {
+ *      name: 'classnames',
+ *      ...
+ *      excludes: ['suitenames']
+ *  },{
+ *      name: 'suitenames',
+ *      ...
+ *  }
+ *
+ *  Results in:
+ *      Usage: <%= command.id %> [-n <string> | -s <string>]
+ *
+ * @example
+ *  {
+ *      name: 'classnames',
+ *      ...
+ *      dependsOn: ['suitenames']
+ *  },{
+ *      name: 'suitenames',
+ *      type: 'flag'
+ *      ...
+ *  }
+ *
+ *  Results in:
+ *      Usage: <%= command.id %> (-n <string> -s)
+ *
+ * TODO:
+ *  - Support nesting, eg:
+ *      Usage: my_program (--either-this <and-that> | <or-this>)
+ *      Usage: my_program [(<one-argument> <another-argument>)]
+ *
+ */
+export declare class DocOpts {
+    private cmd;
+    private flagList;
+    private flagMap;
+    constructor(cmd: Command.Loadable);
+    static formatUsageType(flag: Command.Flag.Any, showFlagName: boolean, showOptions: boolean): string;
+    static generate(cmd: Command.Loadable): string;
+    toString(): string;
+    private combineElementsToFlag;
+    private generateElements;
+    private groupFlagElements;
+}

node_modules/@oclif/core/lib/help/docopts.js

@@ -0,0 +1,197 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DocOpts = void 0;
+const ensure_arg_object_1 = require("../util/ensure-arg-object");
+/**
+ * DocOpts - See http://docopt.org/.
+ *
+ * flag.exclusive: groups elements when one of the mutually exclusive cases is a required flag: (--apple | --orange)
+ * flag.exclusive: groups elements when none of the mutually exclusive cases is required (optional flags): [--apple | --orange]
+ * flag.dependsOn: specifies that if one element is present, then another one is required: (--apple --orange)
+ *
+ * @example
+ *  {
+ *      name: 'classnames',
+ *      required: true,
+ *      exclusive: ['suitenames']
+ *      ...
+ *  },{
+ *      name: 'suitenames',
+ *      type: 'array'
+ *      required: true
+ *      ...
+ *  }
+ *
+ *  Results in:
+ *      Usage: <%= command.id %> (-n <string> | -s <array>)
+ *
+ * @example
+ *  {
+ *      name: 'classnames',
+ *      ...
+ *      excludes: ['suitenames']
+ *  },{
+ *      name: 'suitenames',
+ *      ...
+ *  }
+ *
+ *  Results in:
+ *      Usage: <%= command.id %> [-n <string> | -s <string>]
+ *
+ * @example
+ *  {
+ *      name: 'classnames',
+ *      ...
+ *      dependsOn: ['suitenames']
+ *  },{
+ *      name: 'suitenames',
+ *      type: 'flag'
+ *      ...
+ *  }
+ *
+ *  Results in:
+ *      Usage: <%= command.id %> (-n <string> -s)
+ *
+ * TODO:
+ *  - Support nesting, eg:
+ *      Usage: my_program (--either-this <and-that> | <or-this>)
+ *      Usage: my_program [(<one-argument> <another-argument>)]
+ *
+ */
+class DocOpts {
+    cmd;
+    flagList;
+    flagMap;
+    constructor(cmd) {
+        this.cmd = cmd;
+        // Create a new map with references to the flags that we can manipulate.
+        this.flagMap = {};
+        this.flagList = Object.entries(cmd.flags || {})
+            .filter(([_, flag]) => !flag.hidden)
+            .map(([name, flag]) => {
+            this.flagMap[name] = flag;
+            return flag;
+        });
+    }
+    static formatUsageType(flag, showFlagName, showOptions) {
+        if (flag.type !== 'option')
+            return '';
+        let helpValues;
+        if (flag.helpValue) {
+            // if there is a given helpValue, use it
+            helpValues = typeof flag.helpValue === 'string' ? [flag.helpValue] : flag.helpValue;
+        }
+        else if (flag.options) {
+            // if there are options, show them if wanted
+            helpValues = [showOptions ? flag.options.join('|') : '<option>'];
+        }
+        else if (showFlagName) {
+            helpValues = [flag.name];
+        }
+        else {
+            // default to <value>
+            helpValues = ['<value>'];
+        }
+        return helpValues.map((v) => `${v}${flag.multiple ? '...' : ''}`).join(' ');
+    }
+    static generate(cmd) {
+        return new DocOpts(cmd).toString();
+    }
+    toString() {
+        const opts = ['<%= command.id %>'];
+        if (this.cmd.args) {
+            // If strict is false, add ellipsis to indicate that the argument takes multiple values
+            const suffix = this.cmd.strict === false ? '...' : '';
+            const a = Object.values((0, ensure_arg_object_1.ensureArgObject)(this.cmd.args))
+                .filter((arg) => !arg.hidden)
+                .map((arg) => arg.required ? `${arg.name.toUpperCase()}${suffix}` : `[${arg.name.toUpperCase()}${suffix}]`) || [];
+            opts.push(...a);
+        }
+        try {
+            opts.push(...Object.values(this.groupFlagElements()));
+        }
+        catch {
+            // If there is an error, just return no usage so we don't fail command help.
+            opts.push(...this.flagList.map((flag) => {
+                const name = flag.char ? `-${flag.char}` : `--${flag.name}`;
+                if (flag.type === 'boolean')
+                    return name;
+                return `${name}=${DocOpts.formatUsageType(flag, false, true)}`;
+            }));
+        }
+        return opts.join(' ');
+    }
+    combineElementsToFlag(elementMap, flagName, flagNames, unionString) {
+        if (!this.flagMap[flagName]) {
+            return;
+        }
+        let isRequired = this.flagMap[flagName]?.required;
+        if (typeof isRequired !== 'boolean' || !isRequired) {
+            isRequired = flagNames.reduce((required, toCombine) => required || this.flagMap[toCombine]?.required || false, false);
+        }
+        for (const toCombine of flagNames) {
+            elementMap[flagName] = `${elementMap[flagName] || ''}${unionString}${elementMap[toCombine] || ''}`;
+            // We handled this flag, don't handle it again
+            delete elementMap[toCombine];
+            delete this.flagMap[toCombine];
+        }
+        elementMap[flagName] = isRequired ? `(${elementMap[flagName] || ''})` : `[${elementMap[flagName] || ''}]`;
+        // We handled this flag, don't handle it again
+        delete this.flagMap[flagName];
+    }
+    generateElements(elementMap = {}, flagGroups = []) {
+        const elementStrs = [];
+        for (const flag of flagGroups) {
+            let type = '';
+            // not all flags have short names
+            const flagName = flag.char ? `-${flag.char}` : `--${flag.name}`;
+            if (flag.type === 'option') {
+                type = ` ${DocOpts.formatUsageType(flag, false, true)}`;
+            }
+            const element = `${flagName}${type}`;
+            elementMap[flag.name] = element;
+            elementStrs.push(element);
+        }
+        return elementStrs;
+    }
+    groupFlagElements() {
+        const elementMap = {};
+        // Generate all doc opt elements for combining
+        // Show required flags first
+        this.generateElements(elementMap, this.flagList.filter((flag) => flag.required));
+        // Then show optional flags
+        this.generateElements(elementMap, this.flagList.filter((flag) => !flag.required));
+        for (const flag of this.flagList) {
+            if (Array.isArray(flag.dependsOn)) {
+                this.combineElementsToFlag(elementMap, flag.name, flag.dependsOn, ' ');
+            }
+            let exclusive;
+            if (Array.isArray(flag.exclusive)) {
+                exclusive = new Set(flag.exclusive);
+            }
+            if (Array.isArray(flag.combinable)) {
+                const combinableFlags = new Set(flag.combinable);
+                exclusive ??= new Set();
+                for (const item of this.flagList) {
+                    // each flag not in the "combinable" list, is equivalent to an "exclusive" flag
+                    if (flag !== item && !combinableFlags.has(item.name)) {
+                        exclusive.add(item.name);
+                    }
+                }
+            }
+            if (exclusive !== undefined && exclusive.size > 0) {
+                this.combineElementsToFlag(elementMap, flag.name, [...exclusive], ' | ');
+            }
+        }
+        // Since combineElementsToFlag deletes the references in this.flags when it combines
+        // them, this will go through the remaining list of uncombined elements.
+        for (const remainingFlagName of Object.keys(this.flagMap)) {
+            const remainingFlag = this.flagMap[remainingFlagName] || {};
+            if (!remainingFlag.required) {
+                elementMap[remainingFlag.name] = `[${elementMap[remainingFlag.name] || ''}]`;
+            }
+        }
+        return elementMap;
+    }
+}
+exports.DocOpts = DocOpts;

node_modules/@oclif/core/lib/help/formatter.d.ts

@@ -0,0 +1,96 @@
+import { Command } from '../command';
+import * as Interfaces from '../interfaces';
+export type HelpSectionKeyValueTable = {
+    description: string;
+    name: string;
+}[];
+export type HelpSection = {
+    body: [string, string | undefined][] | HelpSectionKeyValueTable | string | undefined;
+    header: string;
+} | undefined;
+export type HelpSectionRenderer = (data: {
+    args: Command.Arg.Any[];
+    cmd: Command.Loadable;
+    flags: Command.Flag.Any[];
+}, header: string) => HelpSection | HelpSection[] | string | undefined;
+export declare class HelpFormatter {
+    protected config: Interfaces.Config;
+    indentSpacing: number;
+    protected opts: Interfaces.HelpOptions;
+    /**
+     * Takes a string and replaces `<%= prop =>` with the value of prop, where prop is anything on
+     * `config=Interfaces.Config` or `opts=Interface.HelpOptions`.
+     *
+     * ```javascript
+     * `<%= config.bin =>` // will resolve to the bin defined in `pjson.oclif`.
+     * ```
+     */
+    render: (input: string) => string;
+    constructor(config: Interfaces.Config, opts?: Partial<Interfaces.HelpOptions>);
+    /**
+     * Indent by `this.indentSpacing`. The text should be wrap based on terminal width before indented.
+     *
+     * In order to call indent multiple times on the same set or text, the caller must wrap based on
+     * the number of times the text has been indented. For example.
+     *
+     * ```javascript
+     * const body = `main line\n${indent(wrap('indented example line', 4))}`
+     * const header = 'SECTION'
+     * console.log(`${header}\n${indent(wrap(body))}`
+     * ```
+     * will output
+     * ```
+     * SECTION
+     *   main line
+     *     indented example line
+     * ```
+     *
+     * If the terminal width was 24 and the `4` was not provided in the first wrap, it would like like the following.
+     * ```
+     * SECTION
+     *   main line
+     *     indented example
+     *   line
+     * ```
+     * @param body the text to indent
+     * @param spacing the final number of spaces this text will be indented
+     * @returns the formatted indented text
+     */
+    indent(body: string, spacing?: number): string;
+    renderList(input: (string | undefined)[][], opts: {
+        indentation: number;
+        multiline?: boolean | undefined;
+        spacer?: string | undefined;
+        stripAnsi?: boolean | undefined;
+    }): string;
+    section(header: string, body: [string, string | undefined][] | HelpSection | HelpSectionKeyValueTable | string): string;
+    /**
+     * Wrap text according to `opts.maxWidth` which is typically set to the terminal width. All text
+     * will be rendered before bring wrapped, otherwise it could mess up the lengths.
+     *
+     * A terminal will automatically wrap text, so this method is primarily used for indented
+     * text. For indented text, specify the indentation so it is taken into account during wrapping.
+     *
+     * Here is an example of wrapping with indentation.
+     * ```
+     * <------ terminal window width ------>
+     * <---------- no indentation --------->
+     * This is my text that will be wrapped
+     * once it passes maxWidth.
+     *
+     * <- indent -><------ text space ----->
+     *             This is my text that will
+     *             be wrapped once it passes
+     *             maxWidth.
+     *
+     * <-- indent not taken into account ->
+     *             This is my text that will
+     * be wrapped
+     *             once it passes maxWidth.
+     * ```
+     * @param body the text to wrap
+     * @param spacing the indentation size to subtract from the terminal width
+     * @returns the formatted wrapped text
+     */
+    wrap(body: string, spacing?: number): string;
+}

node_modules/@oclif/core/lib/help/formatter.js

@@ -0,0 +1,194 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HelpFormatter = void 0;
+const ansis_1 = __importDefault(require("ansis"));
+const indent_string_1 = __importDefault(require("indent-string"));
+const string_width_1 = __importDefault(require("string-width"));
+const widest_line_1 = __importDefault(require("widest-line"));
+const wrap_ansi_1 = __importDefault(require("wrap-ansi"));
+const screen_1 = require("../screen");
+const theme_1 = require("../ux/theme");
+const util_1 = require("./util");
+class HelpFormatter {
+    config;
+    indentSpacing = 2;
+    opts;
+    /**
+     * Takes a string and replaces `<%= prop =>` with the value of prop, where prop is anything on
+     * `config=Interfaces.Config` or `opts=Interface.HelpOptions`.
+     *
+     * ```javascript
+     * `<%= config.bin =>` // will resolve to the bin defined in `pjson.oclif`.
+     * ```
+     */
+    render;
+    constructor(config, opts = {}) {
+        this.config = config;
+        this.opts = { maxWidth: screen_1.stdtermwidth, ...opts };
+        this.render = (0, util_1.template)(this);
+    }
+    /**
+     * Indent by `this.indentSpacing`. The text should be wrap based on terminal width before indented.
+     *
+     * In order to call indent multiple times on the same set or text, the caller must wrap based on
+     * the number of times the text has been indented. For example.
+     *
+     * ```javascript
+     * const body = `main line\n${indent(wrap('indented example line', 4))}`
+     * const header = 'SECTION'
+     * console.log(`${header}\n${indent(wrap(body))}`
+     * ```
+     * will output
+     * ```
+     * SECTION
+     *   main line
+     *     indented example line
+     * ```
+     *
+     * If the terminal width was 24 and the `4` was not provided in the first wrap, it would like like the following.
+     * ```
+     * SECTION
+     *   main line
+     *     indented example
+     *   line
+     * ```
+     * @param body the text to indent
+     * @param spacing the final number of spaces this text will be indented
+     * @returns the formatted indented text
+     */
+    indent(body, spacing = this.indentSpacing) {
+        return (0, indent_string_1.default)(body, spacing);
+    }
+    renderList(input, opts) {
+        if (input.length === 0) {
+            return '';
+        }
+        const renderMultiline = () => {
+            let output = '';
+            for (let [left, right] of input) {
+                if (!left && !right)
+                    continue;
+                if (left) {
+                    if (opts.stripAnsi)
+                        left = ansis_1.default.strip(left);
+                    output += this.wrap(left.trim(), opts.indentation);
+                }
+                if (right) {
+                    if (opts.stripAnsi)
+                        right = ansis_1.default.strip(right);
+                    output += '\n';
+                    output += this.indent(this.wrap(right.trim(), opts.indentation + 2), 4);
+                }
+                output += '\n\n';
+            }
+            return output.trim();
+        };
+        if (opts.multiline)
+            return renderMultiline();
+        const maxLength = (0, widest_line_1.default)(input.map((i) => i[0]).join('\n'));
+        let output = '';
+        let spacer = opts.spacer || '\n';
+        let cur = '';
+        for (const [left, r] of input) {
+            let right = r;
+            if (cur) {
+                output += spacer;
+                output += cur;
+            }
+            cur = left || '';
+            if (opts.stripAnsi)
+                cur = ansis_1.default.strip(cur);
+            if (!right) {
+                cur = cur.trim();
+                continue;
+            }
+            if (opts.stripAnsi)
+                right = ansis_1.default.strip(right);
+            right = this.wrap(right.trim(), opts.indentation + maxLength + 2);
+            const [first, ...lines] = right.split('\n').map((s) => s.trim());
+            cur += ' '.repeat(maxLength - (0, string_width_1.default)(cur) + 2);
+            cur += first;
+            if (lines.length === 0) {
+                continue;
+            }
+            // if we start putting too many lines down, render in multiline format
+            if (lines.length > 4)
+                return renderMultiline();
+            // if spacer is not defined, separate all rows with a newline
+            if (!opts.spacer)
+                spacer = '\n';
+            cur += '\n';
+            cur += this.indent(lines.join('\n'), maxLength + 2);
+        }
+        if (cur) {
+            output += spacer;
+            output += cur;
+        }
+        return output.trim();
+    }
+    section(header, body) {
+        // Always render template strings with the provided render function before wrapping and indenting
+        let newBody;
+        if (typeof body === 'string') {
+            newBody = this.render(body);
+        }
+        else if (Array.isArray(body)) {
+            newBody = body.map((entry) => {
+                if ('name' in entry) {
+                    const tableEntry = entry;
+                    return [this.render(tableEntry.name), this.render(tableEntry.description)];
+                }
+                const [left, right] = entry;
+                return [this.render(left), right && this.render(right)];
+            });
+        }
+        else if ('header' in body) {
+            return this.section(body.header, body.body);
+        }
+        else {
+            newBody = body
+                .map((entry) => [entry.name, entry.description])
+                .map(([left, right]) => [this.render(left), right && this.render(right)]);
+        }
+        const output = [
+            (0, theme_1.colorize)(this.config?.theme?.sectionHeader, (0, theme_1.colorize)('bold', header)),
+            (0, theme_1.colorize)(this.config?.theme?.sectionDescription, this.indent(Array.isArray(newBody) ? this.renderList(newBody, { indentation: 2, stripAnsi: this.opts.stripAnsi }) : newBody)),
+        ].join('\n');
+        return this.opts.stripAnsi ? ansis_1.default.strip(output) : output;
+    }
+    /**
+     * Wrap text according to `opts.maxWidth` which is typically set to the terminal width. All text
+     * will be rendered before bring wrapped, otherwise it could mess up the lengths.
+     *
+     * A terminal will automatically wrap text, so this method is primarily used for indented
+     * text. For indented text, specify the indentation so it is taken into account during wrapping.
+     *
+     * Here is an example of wrapping with indentation.
+     * ```
+     * <------ terminal window width ------>
+     * <---------- no indentation --------->
+     * This is my text that will be wrapped
+     * once it passes maxWidth.
+     *
+     * <- indent -><------ text space ----->
+     *             This is my text that will
+     *             be wrapped once it passes
+     *             maxWidth.
+     *
+     * <-- indent not taken into account ->
+     *             This is my text that will
+     * be wrapped
+     *             once it passes maxWidth.
+     * ```
+     * @param body the text to wrap
+     * @param spacing the indentation size to subtract from the terminal width
+     * @returns the formatted wrapped text
+     */
+    wrap(body, spacing = this.indentSpacing) {
+        return (0, wrap_ansi_1.default)(this.render(body), this.opts.maxWidth - spacing, { hard: true });
+    }
+}
+exports.HelpFormatter = HelpFormatter;

node_modules/@oclif/core/lib/help/index.d.ts

@@ -0,0 +1,46 @@
+import { Command } from '../command';
+import * as Interfaces from '../interfaces';
+import { CommandHelp } from './command';
+import { HelpFormatter } from './formatter';
+export { CommandHelp } from './command';
+export { HelpFormatter, type HelpSection, type HelpSectionKeyValueTable, type HelpSectionRenderer } from './formatter';
+export { getHelpFlagAdditions, normalizeArgv, standardizeIDFromArgv } from './util';
+export declare abstract class HelpBase extends HelpFormatter {
+    constructor(config: Interfaces.Config, opts?: Partial<Interfaces.HelpOptions>);
+    /**
+     * Show help for an individual command
+     * @param command
+     * @param topics
+     */
+    abstract showCommandHelp(command: Command.Loadable, topics: Interfaces.Topic[]): Promise<void>;
+    /**
+     * Show help, used in multi-command CLIs
+     * @param args passed into your command, useful for determining which type of help to display
+     */
+    abstract showHelp(argv: string[]): Promise<void>;
+}
+export declare class Help extends HelpBase {
+    protected CommandHelpClass: typeof CommandHelp;
+    constructor(config: Interfaces.Config, opts?: Partial<Interfaces.HelpOptions>);
+    private get _topics();
+    protected get sortedCommands(): Command.Loadable[];
+    protected get sortedTopics(): Interfaces.Topic[];
+    protected command(command: Command.Loadable): string;
+    protected description(c: Command.Loadable): string;
+    protected formatCommand(command: Command.Loadable): string;
+    protected formatCommands(commands: Array<Command.Loadable>): string;
+    protected formatRoot(): string;
+    protected formatTopic(topic: Interfaces.Topic): string;
+    protected formatTopics(topics: Interfaces.Topic[]): string;
+    protected getCommandHelpClass(command: Command.Loadable): CommandHelp;
+    protected log(...args: string[]): void;
+    showCommandHelp(command: Command.Loadable): Promise<void>;
+    showHelp(argv: string[]): Promise<void>;
+    protected showRootHelp(): Promise<void>;
+    protected showTopicHelp(topic: Interfaces.Topic): Promise<void>;
+    protected summary(c: Command.Loadable): string | undefined;
+}
+interface HelpBaseDerived {
+    new (config: Interfaces.Config, opts?: Partial<Interfaces.HelpOptions>): HelpBase;
+}
+export declare function loadHelpClass(config: Interfaces.Config): Promise<HelpBaseDerived>;

node_modules/@oclif/core/lib/help/index.js

@@ -0,0 +1,345 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Help = exports.HelpBase = exports.standardizeIDFromArgv = exports.normalizeArgv = exports.getHelpFlagAdditions = exports.HelpFormatter = exports.CommandHelp = void 0;
+exports.loadHelpClass = loadHelpClass;
+const ansis_1 = __importDefault(require("ansis"));
+const ts_path_1 = require("../config/ts-path");
+const error_1 = require("../errors/error");
+const module_loader_1 = require("../module-loader");
+const symbols_1 = require("../symbols");
+const cache_default_value_1 = require("../util/cache-default-value");
+const ids_1 = require("../util/ids");
+const util_1 = require("../util/util");
+const ux_1 = require("../ux");
+const theme_1 = require("../ux/theme");
+const command_1 = require("./command");
+const formatter_1 = require("./formatter");
+const root_1 = __importDefault(require("./root"));
+const util_2 = require("./util");
+var command_2 = require("./command");
+Object.defineProperty(exports, "CommandHelp", { enumerable: true, get: function () { return command_2.CommandHelp; } });
+var formatter_2 = require("./formatter");
+Object.defineProperty(exports, "HelpFormatter", { enumerable: true, get: function () { return formatter_2.HelpFormatter; } });
+var util_3 = require("./util");
+Object.defineProperty(exports, "getHelpFlagAdditions", { enumerable: true, get: function () { return util_3.getHelpFlagAdditions; } });
+Object.defineProperty(exports, "normalizeArgv", { enumerable: true, get: function () { return util_3.normalizeArgv; } });
+Object.defineProperty(exports, "standardizeIDFromArgv", { enumerable: true, get: function () { return util_3.standardizeIDFromArgv; } });
+function getHelpSubject(args, config) {
+    // for each help flag that starts with '--' create a new flag with same name sans '--'
+    const mergedHelpFlags = (0, util_2.getHelpFlagAdditions)(config);
+    for (const arg of args) {
+        if (arg === '--')
+            return;
+        if (mergedHelpFlags.includes(arg) || arg === 'help')
+            continue;
+        if (arg.startsWith('-'))
+            return;
+        return arg;
+    }
+}
+class HelpBase extends formatter_1.HelpFormatter {
+    constructor(config, opts = {}) {
+        super(config, opts);
+        if (!config.topicSeparator)
+            config.topicSeparator = ':'; // back-support @oclif/config
+    }
+}
+exports.HelpBase = HelpBase;
+class Help extends HelpBase {
+    CommandHelpClass = command_1.CommandHelp;
+    constructor(config, opts = {}) {
+        super(config, opts);
+    }
+    /*
+     * _topics is to work around Interfaces.topics mistakenly including commands that do
+     * not have children, as well as topics. A topic has children, either commands or other topics. When
+     * this is fixed upstream config.topics should return *only* topics with children,
+     * and this can be removed.
+     */
+    get _topics() {
+        return this.config.topics.filter((topic) => {
+            // it is assumed a topic has a child if it has children
+            const hasChild = this.config.topics.some((subTopic) => subTopic.name.includes(`${topic.name}:`));
+            return hasChild;
+        });
+    }
+    get sortedCommands() {
+        let { commands } = this.config;
+        commands = commands.filter((c) => this.opts.all || !c.hidden);
+        commands = (0, util_1.sortBy)(commands, (c) => c.id);
+        commands = (0, util_1.uniqBy)(commands, (c) => c.id);
+        return commands;
+    }
+    get sortedTopics() {
+        let topics = this._topics;
+        topics = topics.filter((t) => this.opts.all || !t.hidden);
+        topics = (0, util_1.sortBy)(topics, (t) => t.name);
+        topics = (0, util_1.uniqBy)(topics, (t) => t.name);
+        return topics;
+    }
+    command(command) {
+        return this.formatCommand(command);
+    }
+    description(c) {
+        const description = this.render(c.description || '');
+        if (c.summary) {
+            return description;
+        }
+        return description.split('\n').slice(1).join('\n');
+    }
+    formatCommand(command) {
+        if (this.config.topicSeparator !== ':') {
+            command.id = command.id.replaceAll(':', this.config.topicSeparator);
+            command.aliases = command.aliases && command.aliases.map((a) => a.replaceAll(':', this.config.topicSeparator));
+        }
+        const help = this.getCommandHelpClass(command);
+        return help.generate();
+    }
+    formatCommands(commands) {
+        if (commands.length === 0)
+            return '';
+        const body = this.renderList(commands
+            .filter((c) => (this.opts.hideAliasesFromRoot ? !c.aliases?.includes(c.id) : true))
+            .map((c) => {
+            if (this.config.topicSeparator !== ':')
+                c.id = c.id.replaceAll(':', this.config.topicSeparator);
+            const summary = this.summary(c);
+            return [
+                (0, theme_1.colorize)(this.config?.theme?.command, c.id),
+                summary && (0, theme_1.colorize)(this.config?.theme?.sectionDescription, ansis_1.default.strip(summary)),
+            ];
+        }), {
+            indentation: 2,
+            spacer: '\n',
+            stripAnsi: this.opts.stripAnsi,
+        });
+        return this.section('COMMANDS', body);
+    }
+    formatRoot() {
+        const help = new root_1.default(this.config, this.opts);
+        return help.root();
+    }
+    formatTopic(topic) {
+        let description = this.render(topic.description || '');
+        const summary = description.split('\n')[0];
+        description = description.split('\n').slice(1).join('\n');
+        let topicID = `${topic.name}:COMMAND`;
+        if (this.config.topicSeparator !== ':')
+            topicID = topicID.replaceAll(':', this.config.topicSeparator);
+        let output = (0, util_1.compact)([
+            (0, theme_1.colorize)(this.config?.theme?.commandSummary, summary),
+            this.section(this.opts.usageHeader || 'USAGE', `${(0, theme_1.colorize)(this.config?.theme?.dollarSign, '$')} ${(0, theme_1.colorize)(this.config?.theme?.bin, this.config.bin)} ${topicID}`),
+            description &&
+                this.section('DESCRIPTION', this.wrap((0, theme_1.colorize)(this.config?.theme?.sectionDescription, description))),
+        ]).join('\n\n');
+        if (this.opts.stripAnsi)
+            output = ansis_1.default.strip(output);
+        return output + '\n';
+    }
+    formatTopics(topics) {
+        if (topics.length === 0)
+            return '';
+        const body = this.renderList(topics.map((c) => {
+            if (this.config.topicSeparator !== ':')
+                c.name = c.name.replaceAll(':', this.config.topicSeparator);
+            return [
+                (0, theme_1.colorize)(this.config?.theme?.topic, c.name),
+                c.description && this.render((0, theme_1.colorize)(this.config?.theme?.sectionDescription, c.description.split('\n')[0])),
+            ];
+        }), {
+            indentation: 2,
+            spacer: '\n',
+            stripAnsi: this.opts.stripAnsi,
+        });
+        return this.section('TOPICS', body);
+    }
+    getCommandHelpClass(command) {
+        return new this.CommandHelpClass(command, this.config, this.opts);
+    }
+    log(...args) {
+        return this.opts.sendToStderr ? ux_1.ux.stderr(args) : ux_1.ux.stdout(args);
+    }
+    async showCommandHelp(command) {
+        const name = command.id;
+        const depth = name.split(':').length;
+        const subTopics = this.sortedTopics.filter((t) => t.name.startsWith(name + ':') && t.name.split(':').length === depth + 1);
+        const subCommands = this.sortedCommands.filter((c) => c.id.startsWith(name + ':') && c.id.split(':').length === depth + 1);
+        const plugin = this.config.plugins.get(command.pluginName);
+        const state = this.config.pjson?.oclif?.state || plugin?.pjson?.oclif?.state || command.state;
+        if (state) {
+            this.log(state === 'deprecated'
+                ? `${(0, util_2.formatCommandDeprecationWarning)((0, ids_1.toConfiguredId)(name, this.config), command.deprecationOptions)}\n`
+                : `This command is in ${state}.\n`);
+        }
+        if (command.deprecateAliases && command.aliases.includes(name)) {
+            const actualCmd = this.config.commands.find((c) => c.aliases.includes(name));
+            const actualCmdName = actualCmd ? (0, ids_1.toConfiguredId)(actualCmd.id, this.config) : '';
+            const opts = { ...command.deprecationOptions, ...(actualCmd ? { to: actualCmdName } : {}) };
+            this.log(`${(0, util_2.formatCommandDeprecationWarning)((0, ids_1.toConfiguredId)(name, this.config), opts)}\n`);
+        }
+        const summary = this.summary(command);
+        if (summary) {
+            this.log(summary + '\n');
+        }
+        this.log(this.formatCommand(command));
+        this.log('');
+        if (subTopics.length > 0) {
+            this.log(this.formatTopics(subTopics));
+            this.log('');
+        }
+        if (subCommands.length > 0) {
+            const aliases = [];
+            const uniqueSubCommands = subCommands.filter((p) => {
+                aliases.push(...p.aliases);
+                return !aliases.includes(p.id);
+            });
+            this.log(this.formatCommands(uniqueSubCommands));
+            this.log('');
+        }
+    }
+    async showHelp(argv) {
+        const originalArgv = argv.slice(1);
+        argv = argv.filter((arg) => !(0, util_2.getHelpFlagAdditions)(this.config).includes(arg));
+        if (this.config.topicSeparator !== ':')
+            argv = (0, util_2.standardizeIDFromArgv)(argv, this.config);
+        const subject = getHelpSubject(argv, this.config);
+        if (!subject) {
+            if (this.config.isSingleCommandCLI) {
+                const rootCmd = this.config.findCommand(symbols_1.SINGLE_COMMAND_CLI_SYMBOL);
+                if (rootCmd) {
+                    // set the command id to an empty string to prevent the
+                    // SINGLE_COMMAND_CLI_SYMBOL from being displayed in the help output
+                    rootCmd.id = '';
+                    await this.showCommandHelp(rootCmd);
+                    return;
+                }
+            }
+            await this.showRootHelp();
+            return;
+        }
+        const command = this.config.findCommand(subject);
+        if (command) {
+            if (command.id === symbols_1.SINGLE_COMMAND_CLI_SYMBOL) {
+                // If the command is the root command of a single command CLI,
+                // then set the command id to an empty string to prevent the
+                // the SINGLE_COMMAND_CLI_SYMBOL from being displayed in the help output.
+                command.id = '';
+            }
+            if (command.hasDynamicHelp && command.pluginType !== 'jit') {
+                const loaded = await command.load();
+                for (const [name, flag] of Object.entries(loaded.flags ?? {})) {
+                    // As of v3 each flag that needs to be re-evaluated has the `hasDynamicHelp` property.
+                    // However, we cannot assume that the absence of this property means that the flag
+                    // doesn't need to be re-evaluated since any command from a v2 or older plugin will
+                    // not have the `hasDynamicHelp` property on it.
+                    // In the future we could improve performance by skipping any flag that doesn't
+                    // have `hasDynamicHelp === true`
+                    if (flag.type === 'boolean')
+                        continue;
+                    // eslint-disable-next-line no-await-in-loop
+                    command.flags[name].default = await (0, cache_default_value_1.cacheDefaultValue)(flag, false);
+                }
+                await this.showCommandHelp(command);
+            }
+            else {
+                await this.showCommandHelp(command);
+            }
+            return;
+        }
+        const topic = this.config.findTopic(subject);
+        if (topic) {
+            await this.showTopicHelp(topic);
+            return;
+        }
+        if (this.config.flexibleTaxonomy) {
+            const matches = this.config.findMatches(subject, originalArgv);
+            if (matches.length > 0) {
+                const result = await this.config.runHook('command_incomplete', {
+                    argv: originalArgv.filter((o) => !subject.split(':').includes(o)),
+                    id: subject,
+                    matches,
+                });
+                if (result.successes.length > 0)
+                    return;
+            }
+        }
+        (0, error_1.error)(`Command ${subject} not found.`);
+    }
+    async showRootHelp() {
+        let rootTopics = this.sortedTopics;
+        let rootCommands = this.sortedCommands;
+        const state = this.config.pjson?.oclif?.state;
+        if (state) {
+            this.log(state === 'deprecated' ? `${this.config.bin} is deprecated` : `${this.config.bin} is in ${state}.\n`);
+        }
+        this.log(this.formatRoot());
+        this.log('');
+        if (!this.opts.all) {
+            rootTopics = rootTopics.filter((t) => !t.name.includes(':'));
+            rootCommands = rootCommands.filter((c) => !c.id.includes(':'));
+        }
+        if (rootTopics.length > 0) {
+            this.log(this.formatTopics(rootTopics));
+            this.log('');
+        }
+        if (rootCommands.length > 0) {
+            rootCommands = rootCommands.filter((c) => c.id);
+            this.log(this.formatCommands(rootCommands));
+            this.log('');
+        }
+    }
+    async showTopicHelp(topic) {
+        const { name } = topic;
+        const depth = name.split(':').length;
+        const subTopics = this.sortedTopics.filter((t) => t.name.startsWith(name + ':') && t.name.split(':').length === depth + 1);
+        const commands = this.sortedCommands.filter((c) => c.id.startsWith(name + ':') && c.id.split(':').length === depth + 1);
+        const state = this.config.pjson?.oclif?.state;
+        if (state)
+            this.log(`This topic is in ${state}.\n`);
+        this.log(this.formatTopic(topic));
+        if (subTopics.length > 0) {
+            this.log(this.formatTopics(subTopics));
+            this.log('');
+        }
+        if (commands.length > 0) {
+            this.log(this.formatCommands(commands));
+            this.log('');
+        }
+    }
+    summary(c) {
+        if (this.opts.sections && !this.opts.sections.map((s) => s.toLowerCase()).includes('summary'))
+            return;
+        if (c.summary)
+            return (0, theme_1.colorize)(this.config?.theme?.commandSummary, this.render(c.summary.split('\n')[0]));
+        return c.description && (0, theme_1.colorize)(this.config?.theme?.commandSummary, this.render(c.description).split('\n')[0]);
+    }
+}
+exports.Help = Help;
+function extractClass(exported) {
+    return exported && exported.default ? exported.default : exported;
+}
+function determineLocation(helpClass) {
+    if (typeof helpClass === 'string')
+        return { identifier: 'default', target: helpClass };
+    if (!helpClass.identifier)
+        return { ...helpClass, identifier: 'default' };
+    return helpClass;
+}
+async function loadHelpClass(config) {
+    if (config.pjson.oclif?.helpClass) {
+        const { identifier, target } = determineLocation(config.pjson.oclif?.helpClass);
+        try {
+            const path = (await (0, ts_path_1.tsPath)(config.root, target)) ?? target;
+            const module = await (0, module_loader_1.load)(config, path);
+            const helpClass = module[identifier] ?? (identifier === 'default' ? extractClass(module) : undefined);
+            return extractClass(helpClass);
+        }
+        catch (error) {
+            throw new Error(`Unable to load configured help class "${target}", failed with message:\n${error.message}`);
+        }
+    }
+    return Help;
+}

node_modules/@oclif/core/lib/help/root.d.ts

@@ -0,0 +1,11 @@
+import * as Interfaces from '../interfaces';
+import { HelpFormatter } from './formatter';
+export default class RootHelp extends HelpFormatter {
+    config: Interfaces.Config;
+    opts: Interfaces.HelpOptions;
+    constructor(config: Interfaces.Config, opts: Interfaces.HelpOptions);
+    protected description(): string | undefined;
+    root(): string;
+    protected usage(): string;
+    protected version(): string;
+}

node_modules/@oclif/core/lib/help/root.js

@@ -0,0 +1,47 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ansis_1 = __importDefault(require("ansis"));
+const util_1 = require("../util/util");
+const theme_1 = require("../ux/theme");
+const formatter_1 = require("./formatter");
+class RootHelp extends formatter_1.HelpFormatter {
+    config;
+    opts;
+    constructor(config, opts) {
+        super(config, opts);
+        this.config = config;
+        this.opts = opts;
+    }
+    description() {
+        let description = this.config.pjson.oclif.description || this.config.pjson.description || '';
+        description = this.render(description);
+        description = description.split('\n').slice(1).join('\n');
+        if (!description)
+            return;
+        return this.section('DESCRIPTION', this.wrap((0, theme_1.colorize)(this.config?.theme?.sectionDescription, description)));
+    }
+    root() {
+        let description = this.config.pjson.oclif.description || this.config.pjson.description || '';
+        description = this.render(description);
+        description = description.split('\n')[0];
+        let output = (0, util_1.compact)([
+            (0, theme_1.colorize)(this.config?.theme?.commandSummary, description),
+            this.version(),
+            this.usage(),
+            this.description(),
+        ]).join('\n\n');
+        if (this.opts.stripAnsi)
+            output = ansis_1.default.strip(output);
+        return output;
+    }
+    usage() {
+        return this.section(this.opts.usageHeader || 'USAGE', this.wrap(`${(0, theme_1.colorize)(this.config?.theme?.dollarSign, '$')} ${(0, theme_1.colorize)(this.config?.theme?.bin, this.config.bin)} ${(0, theme_1.colorize)(this.config?.theme?.sectionDescription, '[COMMAND]')}`));
+    }
+    version() {
+        return this.section('VERSION', this.wrap((0, theme_1.colorize)(this.config?.theme?.version, this.config.userAgent)));
+    }
+}
+exports.default = RootHelp;

node_modules/@oclif/core/lib/help/util.d.ts

@@ -0,0 +1,7 @@
+import { Deprecation, Config as IConfig } from '../interfaces';
+export declare function template(context: any): (t: string) => string;
+export declare function standardizeIDFromArgv(argv: string[], config: IConfig): string[];
+export declare function getHelpFlagAdditions(config: IConfig): string[];
+export declare function formatFlagDeprecationWarning(flag: string, opts: Deprecation | true): string;
+export declare function formatCommandDeprecationWarning(command: string, opts?: Deprecation): string;
+export declare function normalizeArgv(config: IConfig, argv?: string[]): string[];

node_modules/@oclif/core/lib/help/util.js

@@ -0,0 +1,129 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.template = template;
+exports.standardizeIDFromArgv = standardizeIDFromArgv;
+exports.getHelpFlagAdditions = getHelpFlagAdditions;
+exports.formatFlagDeprecationWarning = formatFlagDeprecationWarning;
+exports.formatCommandDeprecationWarning = formatCommandDeprecationWarning;
+exports.normalizeArgv = normalizeArgv;
+const ejs = __importStar(require("ejs"));
+const util_1 = require("../config/util");
+const ids_1 = require("../util/ids");
+function template(context) {
+    function render(t) {
+        return ejs.render(t, context);
+    }
+    return render;
+}
+const isFlag = (s) => s.startsWith('-');
+const isArgWithValue = (s) => s.includes('=');
+function collateSpacedCmdIDFromArgs(argv, config) {
+    if (argv.length === 1)
+        return argv;
+    const findId = (argv) => {
+        const ids = (0, util_1.collectUsableIds)(config.commandIDs);
+        const final = [];
+        const idPresent = (id) => ids.has(id);
+        const finalizeId = (s) => (s ? [...final, s] : final).filter(Boolean).join(':');
+        const hasArgs = () => {
+            const id = finalizeId();
+            if (!id)
+                return false;
+            const cmd = config.findCommand(id);
+            return Boolean(cmd && (cmd.strict === false || Object.keys(cmd.args ?? {}).length > 0));
+        };
+        for (const arg of argv) {
+            if (idPresent(finalizeId(arg)))
+                final.push(arg);
+            // If the parent topic has a command that expects positional arguments, then we cannot
+            // assume that any subsequent string could be part of the command name
+            else if (isArgWithValue(arg) || isFlag(arg) || hasArgs())
+                break;
+            else
+                final.push(arg);
+        }
+        return finalizeId();
+    };
+    const id = findId(argv);
+    if (id) {
+        const argvSlice = argv.slice(id.split(':').length);
+        return [id, ...argvSlice];
+    }
+    return argv; // ID is argv[0]
+}
+function standardizeIDFromArgv(argv, config) {
+    if (argv.length === 0)
+        return argv;
+    if (config.topicSeparator === ' ')
+        argv = collateSpacedCmdIDFromArgs(argv, config);
+    else if (config.topicSeparator !== ':')
+        argv[0] = (0, ids_1.toStandardizedId)(argv[0], config);
+    return argv;
+}
+function getHelpFlagAdditions(config) {
+    const helpFlags = ['--help'];
+    const additionalHelpFlags = config.pjson.oclif.additionalHelpFlags ?? [];
+    return [...new Set([...additionalHelpFlags, ...helpFlags]).values()];
+}
+function formatFlagDeprecationWarning(flag, opts) {
+    let message = `The "${flag}" flag has been deprecated`;
+    if (opts === true)
+        return `${message}.`;
+    if (opts.message)
+        return opts.message;
+    if (opts.version) {
+        message += ` and will be removed in version ${opts.version}`;
+    }
+    message += opts.to ? `. Use "${opts.to}" instead.` : '.';
+    return message;
+}
+function formatCommandDeprecationWarning(command, opts) {
+    let message = `The "${command}" command has been deprecated`;
+    if (!opts)
+        return `${message}.`;
+    if (opts.message)
+        return opts.message;
+    if (opts.version) {
+        message += ` and will be removed in version ${opts.version}`;
+    }
+    message += opts.to ? `. Use "${opts.to}" instead.` : '.';
+    return message;
+}
+function normalizeArgv(config, argv = process.argv.slice(2)) {
+    if (config.topicSeparator !== ':' && !argv[0]?.includes(':'))
+        argv = standardizeIDFromArgv(argv, config);
+    return argv;
+}

node_modules/@oclif/core/lib/index.d.ts

@@ -0,0 +1,19 @@
+export * as Args from './args';
+export { Command } from './command';
+export { Config, Plugin } from './config';
+export * as Errors from './errors';
+export { handle } from './errors/handle';
+export { execute } from './execute';
+export * as Flags from './flags';
+export { flush } from './flush';
+export { CommandHelp, Help, HelpBase, type HelpSection, type HelpSectionKeyValueTable, type HelpSectionRenderer, loadHelpClass, } from './help';
+export * as Interfaces from './interfaces';
+export { type Hook } from './interfaces/hooks';
+export { getLogger } from './logger';
+export { run } from './main';
+export * as ModuleLoader from './module-loader';
+export * as Parser from './parser';
+export { Performance } from './performance';
+export { type Settings, settings } from './settings';
+export { toConfiguredId, toStandardizedId } from './util/ids';
+export { ux } from './ux';

node_modules/@oclif/core/lib/index.js

@@ -0,0 +1,100 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ux = exports.toStandardizedId = exports.toConfiguredId = exports.settings = exports.Performance = exports.Parser = exports.ModuleLoader = exports.getLogger = exports.Interfaces = exports.loadHelpClass = exports.HelpBase = exports.Help = exports.CommandHelp = exports.flush = exports.Flags = exports.execute = exports.handle = exports.Errors = exports.Plugin = exports.Config = exports.Command = exports.Args = void 0;
+const util_1 = require("./util/util");
+function checkCWD() {
+    try {
+        process.cwd();
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            process.stderr.write('WARNING: current directory does not exist\n');
+        }
+    }
+}
+function checkNodeVersion() {
+    if (process.env.OCLIF_DISABLE_ENGINE_WARNING && (0, util_1.isTruthy)(process.env.OCLIF_DISABLE_ENGINE_WARNING))
+        return;
+    try {
+        const path = require('node:path');
+        const semver = require('semver');
+        const root = path.join(__dirname, '..');
+        const pjson = require(path.join(root, 'package.json'));
+        if (!semver.satisfies(process.versions.node, pjson.engines.node)) {
+            process.emitWarning(`Node version must be ${pjson.engines.node} to use this CLI. Current node version: ${process.versions.node}`);
+        }
+    }
+    catch {
+        // ignore
+    }
+}
+checkCWD();
+checkNodeVersion();
+exports.Args = __importStar(require("./args"));
+var command_1 = require("./command");
+Object.defineProperty(exports, "Command", { enumerable: true, get: function () { return command_1.Command; } });
+var config_1 = require("./config");
+Object.defineProperty(exports, "Config", { enumerable: true, get: function () { return config_1.Config; } });
+Object.defineProperty(exports, "Plugin", { enumerable: true, get: function () { return config_1.Plugin; } });
+exports.Errors = __importStar(require("./errors"));
+var handle_1 = require("./errors/handle");
+Object.defineProperty(exports, "handle", { enumerable: true, get: function () { return handle_1.handle; } });
+var execute_1 = require("./execute");
+Object.defineProperty(exports, "execute", { enumerable: true, get: function () { return execute_1.execute; } });
+exports.Flags = __importStar(require("./flags"));
+var flush_1 = require("./flush");
+Object.defineProperty(exports, "flush", { enumerable: true, get: function () { return flush_1.flush; } });
+var help_1 = require("./help");
+Object.defineProperty(exports, "CommandHelp", { enumerable: true, get: function () { return help_1.CommandHelp; } });
+Object.defineProperty(exports, "Help", { enumerable: true, get: function () { return help_1.Help; } });
+Object.defineProperty(exports, "HelpBase", { enumerable: true, get: function () { return help_1.HelpBase; } });
+Object.defineProperty(exports, "loadHelpClass", { enumerable: true, get: function () { return help_1.loadHelpClass; } });
+exports.Interfaces = __importStar(require("./interfaces"));
+var logger_1 = require("./logger");
+Object.defineProperty(exports, "getLogger", { enumerable: true, get: function () { return logger_1.getLogger; } });
+var main_1 = require("./main");
+Object.defineProperty(exports, "run", { enumerable: true, get: function () { return main_1.run; } });
+exports.ModuleLoader = __importStar(require("./module-loader"));
+exports.Parser = __importStar(require("./parser"));
+var performance_1 = require("./performance");
+Object.defineProperty(exports, "Performance", { enumerable: true, get: function () { return performance_1.Performance; } });
+var settings_1 = require("./settings");
+Object.defineProperty(exports, "settings", { enumerable: true, get: function () { return settings_1.settings; } });
+var ids_1 = require("./util/ids");
+Object.defineProperty(exports, "toConfiguredId", { enumerable: true, get: function () { return ids_1.toConfiguredId; } });
+Object.defineProperty(exports, "toStandardizedId", { enumerable: true, get: function () { return ids_1.toStandardizedId; } });
+var ux_1 = require("./ux");
+Object.defineProperty(exports, "ux", { enumerable: true, get: function () { return ux_1.ux; } });

node_modules/@oclif/core/lib/interfaces/alphabet.d.ts

@@ -0,0 +1,2 @@
+export type AlphabetUppercase = 'A' | 'B' | 'C' | 'D' | 'E' | 'F' | 'G' | 'H' | 'I' | 'J' | 'K' | 'L' | 'M' | 'N' | 'O' | 'P' | 'Q' | 'R' | 'S' | 'T' | 'U' | 'V' | 'W' | 'X' | 'Y' | 'Z';
+export type AlphabetLowercase = 'a' | 'b' | 'c' | 'd' | 'e' | 'f' | 'g' | 'h' | 'i' | 'j' | 'k' | 'l' | 'm' | 'n' | 'o' | 'p' | 'q' | 'r' | 's' | 't' | 'u' | 'v' | 'w' | 'x' | 'y' | 'z';

node_modules/@oclif/core/lib/interfaces/alphabet.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

node_modules/@oclif/core/lib/interfaces/args.d.ts

@@ -0,0 +1,22 @@
+import { ArgInput } from './parser';
+/**
+ * Infer the args that are returned by Command.parse. This is useful for when you want to assign the args as a class property.
+ *
+ * @example
+ * export type StatusArgs = Interfaces.InferredArgs<typeof Status.args>
+ *
+ * export default class Status {
+ *   static args = {
+ *     force: Args.boolean({char: 'f', description: 'a flag'}),
+ *   }
+ *
+ *   public args!: StatusArgs
+ *
+ *   public async run(): Promise<StatusArgs> {
+ *     const result = await this.parse(Status)
+ *     this.args = result.args
+ *     return result.args
+ *   }
+ * }
+ */
+export type InferredArgs<T> = T extends ArgInput<infer F> ? F : unknown;

node_modules/@oclif/core/lib/interfaces/args.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

node_modules/@oclif/core/lib/interfaces/config.d.ts

@@ -0,0 +1,139 @@
+import { Command } from '../command';
+import { Hook, Hooks } from './hooks';
+import { OclifConfiguration, PJSON, S3Templates } from './pjson';
+import { Options, Plugin } from './plugin';
+import { Theme } from './theme';
+import { Topic } from './topic';
+export type LoadOptions = Config | Options | string | undefined;
+export type PlatformTypes = 'wsl' | NodeJS.Platform;
+export type ArchTypes = 'arm' | 'arm64' | 'mips' | 'mipsel' | 'ppc' | 'ppc64' | 's390' | 's390x' | 'x32' | 'x64' | 'x86';
+export type PluginVersionDetail = {
+    root: string;
+    type: string;
+    version: string;
+};
+export type VersionDetails = {
+    architecture: string;
+    cliVersion: string;
+    nodeVersion: string;
+    osVersion?: string;
+    pluginVersions?: Record<string, PluginVersionDetail>;
+    rootPath?: string;
+    shell?: string;
+};
+export interface Config {
+    /**
+     * process.arch
+     */
+    readonly arch: ArchTypes;
+    /**
+     * bin name of CLI command
+     */
+    readonly bin: string;
+    /**
+     * name of any bin aliases that will execute the cli
+     */
+    readonly binAliases?: string[] | undefined;
+    readonly binPath?: string | undefined;
+    /**
+     * cache directory to use for CLI
+     *
+     * example ~/Library/Caches/mycli or ~/.cache/mycli
+     */
+    readonly cacheDir: string;
+    readonly channel: string;
+    readonly commandIDs: string[];
+    readonly commands: Command.Loadable[];
+    /**
+     * config directory to use for CLI
+     *
+     * example: ~/.config/mycli
+     */
+    readonly configDir: string;
+    /**
+     * data directory to use for CLI
+     *
+     * example: ~/.local/share/mycli
+     */
+    readonly dataDir: string;
+    /**
+     * base dirname to use in cacheDir/configDir/dataDir
+     */
+    readonly dirname: string;
+    findCommand(id: string, opts: {
+        must: true;
+    }): Command.Loadable;
+    findCommand(id: string, opts?: {
+        must: boolean;
+    }): Command.Loadable | undefined;
+    findMatches(id: string, argv: string[]): Command.Loadable[];
+    findTopic(id: string, opts: {
+        must: true;
+    }): Topic;
+    findTopic(id: string, opts?: {
+        must: boolean;
+    }): Topic | undefined;
+    readonly flexibleTaxonomy?: boolean;
+    getAllCommandIDs(): string[];
+    getAllCommands(): Command.Loadable[];
+    getPluginsList(): Plugin[];
+    /**
+     * path to home directory
+     *
+     * example: /home/myuser
+     */
+    readonly home: string;
+    readonly isSingleCommandCLI: boolean;
+    readonly name: string;
+    /**
+     * npm registry to use for installing plugins
+     */
+    readonly npmRegistry?: string | undefined;
+    readonly nsisCustomization?: string | undefined;
+    readonly pjson: PJSON;
+    /**
+     * process.platform
+     */
+    readonly platform: PlatformTypes;
+    readonly plugins: Map<string, Plugin>;
+    readonly root: string;
+    runCommand<T = unknown>(id: string, argv?: string[], cachedCommand?: Command.Loadable): Promise<T>;
+    runHook<T extends keyof Hooks>(event: T, opts: Hooks[T]['options'], timeout?: number, captureErrors?: boolean): Promise<Hook.Result<Hooks[T]['return']>>;
+    s3Key(type: 'unversioned' | 'versioned', ext: '.tar.gz' | '.tar.xz', options?: Config.s3Key.Options): string;
+    s3Key(type: keyof S3Templates, options?: Config.s3Key.Options): string;
+    s3Url(key: string): string;
+    scopedEnvVar(key: string): string | undefined;
+    scopedEnvVarKey(key: string): string;
+    scopedEnvVarKeys(key: string): string[];
+    scopedEnvVarTrue(key: string): boolean;
+    /**
+     * active shell
+     */
+    readonly shell: string;
+    readonly theme?: Theme | undefined;
+    readonly topics: Topic[];
+    topicSeparator: ' ' | ':';
+    readonly updateConfig: NonNullable<OclifConfiguration['update']>;
+    /**
+     * user agent to use for http calls
+     *
+     * example: mycli/1.2.3 (darwin-x64) node-9.0.0
+     */
+    readonly userAgent: string;
+    readonly valid: boolean;
+    readonly version: string;
+    readonly versionDetails: VersionDetails;
+    /**
+     * if windows
+     */
+    readonly windows: boolean;
+}
+export declare namespace Config {
+    namespace s3Key {
+        interface Options {
+            [key: string]: any;
+            arch?: ArchTypes;
+            platform?: PlatformTypes;
+        }
+    }
+}

node_modules/@oclif/core/lib/interfaces/config.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

node_modules/@oclif/core/lib/interfaces/errors.d.ts

@@ -0,0 +1,27 @@
+export type CommandError = Error & {
+    exitCode?: number;
+};
+export interface OclifError {
+    oclif: {
+        exit?: number | undefined;
+    };
+}
+export interface PrettyPrintableError {
+    /**
+     * a unique error code for this error class
+     */
+    code?: string | undefined;
+    /**
+     * message to display related to the error
+     */
+    message?: string | undefined;
+    /**
+     * a url to find out more information related to this error
+     * or fixing the error
+     */
+    ref?: string | undefined;
+    /**
+     * a suggestion that may be useful or provide additional context
+     */
+    suggestions?: string[] | undefined;
+}

node_modules/@oclif/core/lib/interfaces/errors.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

node_modules/@oclif/core/lib/interfaces/flags.d.ts

@@ -0,0 +1,34 @@
+import { FlagInput } from './parser';
+/**
+ * Infer the flags that are returned by Command.parse. This is useful for when you want to assign the flags as a class property.
+ *
+ * @example
+ * export type StatusFlags = Interfaces.InferredFlags<typeof Status.flags && typeof Status.baseFlags>
+ *
+ * export abstract class BaseCommand extends Command {
+ *   static enableJsonFlag = true
+ *
+ *   static flags = {
+ *     config: Flags.string({
+ *       description: 'specify config file',
+ *     }),
+ *   }
+ * }
+ *
+ * export default class Status extends BaseCommand {
+ *   static flags = {
+ *     force: Flags.boolean({char: 'f', description: 'a flag'}),
+ *   }
+ *
+ *   public flags!: StatusFlags
+ *
+ *   public async run(): Promise<StatusFlags> {
+ *     const result = await this.parse(Status)
+ *     this.flags = result.flags
+ *     return result.flags
+ *   }
+ * }
+ */
+export type InferredFlags<T> = T extends FlagInput<infer F> ? F & {
+    json: boolean | undefined;
+} : unknown;

node_modules/@oclif/core/lib/interfaces/flags.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

node_modules/@oclif/core/lib/interfaces/help.d.ts

@@ -0,0 +1,58 @@
+export interface HelpOptions {
+    all?: boolean;
+    /**
+     * Use docopts as the usage. Defaults to true.
+     */
+    docopts?: boolean;
+    /**
+     * Order in which to sort flags in help output. Defaults to `alphabetical`.
+     *
+     * `alphabetical`: Sort flags alphabetically. All flags with short characters will come first.
+     * `none`: Do not sort flags. They will appear in the order in which they were defined on the command.
+     */
+    flagSortOrder?: 'alphabetical' | 'none';
+    /**
+     * If true, hide command aliases from the root help output. Defaults to false.
+     */
+    hideAliasesFromRoot?: boolean;
+    /**
+     * By default, the command summary is show at the top of the help and as the first line in
+     * the command description. Repeating the summary in the command description improves readability
+     * especially for long command help output. If there is no `command.summary`, the first line of
+     * the description is treated as the summary. Some CLIs, especially with very simple commands, may
+     * not want the duplication.
+     */
+    hideCommandSummaryInDescription?: boolean;
+    maxWidth: number;
+    /**
+     * Respect the `noCacheDefault` property on flags. Defaults to false.
+     */
+    respectNoCacheDefault?: boolean;
+    /**
+     * Only show the help for the specified sections. Defaults to all sections.
+     */
+    sections?: string[];
+    /**
+     * By default, the help output is sent to stdout. If this is true, it will be sent to stderr.
+     */
+    sendToStderr?: boolean;
+    /**
+     * By default, titles show flag values as `<value>`. Some CLI developers may prefer titles
+     * to show the flag name as the value. i.e. `--myflag=myflag` instead of `--myflag=<value>`.
+     * An individual flag can set this using `flag.helpValue=flag.name`.
+     */
+    showFlagNameInTitle?: boolean;
+    /**
+     * By default, option values on flags are shown in the flag's description. This is because
+     * long options list ruin the formatting of help. If a CLI knows all commands will not
+     * do this, it can be turned off at a help level using this property. An individual flag
+     * can set this using `flag.helpValue=options.join('|')`.
+     */
+    showFlagOptionsInTitle?: boolean;
+    stripAnsi?: boolean;
+    /**
+     * Use USAGE, but some may want to use USAGE as used in gnu man pages. See help recommendations at
+     * http://www.gnu.org/software/help2man/#--help-recommendations
+     */
+    usageHeader?: string;
+}

node_modules/@oclif/core/lib/interfaces/help.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

node_modules/@oclif/core/lib/interfaces/hooks.d.ts

@@ -0,0 +1,185 @@
+import { Command } from '../command';
+import { Config } from './config';
+import { Input, OutputFlags } from './parser';
+import { Plugin } from './plugin';
+interface HookMeta {
+    options: Record<string, unknown>;
+    return: any;
+}
+type Context = {
+    debug(...args: any[]): void;
+    error(message: Error | string, options?: {
+        code?: string;
+        exit?: number;
+    }): void;
+    exit(code?: number): void;
+    log(message?: any, ...args: any[]): void;
+    warn(message: string): void;
+};
+export interface Hooks {
+    [event: string]: HookMeta;
+    command_incomplete: {
+        options: {
+            argv: string[];
+            id: string;
+            matches: Command.Loadable[];
+        };
+        return: unknown;
+    };
+    command_not_found: {
+        options: {
+            argv?: string[];
+            id: string;
+        };
+        return: unknown;
+    };
+    finally: {
+        options: {
+            argv: string[];
+            id: string;
+            Command: Command.Loadable | undefined;
+            error: Error | undefined;
+        };
+        return: void;
+    };
+    init: {
+        options: {
+            argv: string[];
+            id: string | undefined;
+        };
+        return: void;
+    };
+    jit_plugin_not_installed: {
+        options: {
+            argv: string[];
+            command: Command.Loadable;
+            id: string;
+            pluginName: string;
+            pluginVersion: string;
+        };
+        return: unknown;
+    };
+    'plugins:preinstall': {
+        options: {
+            plugin: {
+                name: string;
+                tag: string;
+                type: 'npm';
+            } | {
+                type: 'repo';
+                url: string;
+            };
+        };
+        return: void;
+    };
+    postrun: {
+        options: {
+            Command: Command.Class;
+            argv: string[];
+            result?: any;
+        };
+        return: void;
+    };
+    preparse: {
+        options: {
+            argv: string[];
+            options: Input<OutputFlags<any>, OutputFlags<any>, OutputFlags<any>>;
+        };
+        return: string[];
+    };
+    prerun: {
+        options: {
+            Command: Command.Class;
+            argv: string[];
+        };
+        return: void;
+    };
+    preupdate: {
+        options: {
+            channel: string;
+            version: string;
+        };
+        return: void;
+    };
+    update: {
+        options: {
+            channel: string;
+            version: string;
+        };
+        return: void;
+    };
+}
+export type Hook<T extends keyof P, P extends Hooks = Hooks> = (this: Hook.Context, options: P[T]['options'] & {
+    config: Config;
+    context: Context;
+}) => Promise<P[T]['return']>;
+export declare namespace Hook {
+    /**
+     * Runs at the end of the CLI lifecycle - regardless of success or failure.
+     */
+    type Finally = Hook<'finally'>;
+    /**
+     * Runs when the CLI is initialized before a command is executed.
+     */
+    type Init = Hook<'init'>;
+    /**
+     * Runs before the `plugins install` command from @oclif/plugin-plugins is run.
+     */
+    type PluginsPreinstall = Hook<'plugins:preinstall'>;
+    /**
+     * Runs after the `init` hook, after a command is found but before it is executed.
+     */
+    type Prerun = Hook<'prerun'>;
+    /**
+     * Runs after a command is successfully executed. Does not run if the command fails.
+     */
+    type Postrun = Hook<'postrun'>;
+    /**
+     * Runs before the CLI is updated by `update` command from @oclif/plugin-update.
+     */
+    type Preupdate = Hook<'preupdate'>;
+    /**
+     * Runs before a command's flags and args are parsed. Useful for modifying the command line arguments before they are parsed.
+     *
+     * The return value is a string[] of the modified arguments.
+     */
+    type Preparse = Hook<'preparse'>;
+    /**
+     * Runs once the `update` command from @oclif/plugin-update is run.
+     */
+    type Update = Hook<'update'>;
+    /**
+     * Runs when a command is not found.
+     */
+    type CommandNotFound = Hook<'command_not_found'>;
+    /**
+     * Runs when a partial command is entered and no matching command is found.
+     */
+    type CommandIncomplete = Hook<'command_incomplete'>;
+    /**
+     * Runs when a command from an uninstalled JIT plugins is run.
+     */
+    type JitPluginNotInstalled = Hook<'jit_plugin_not_installed'>;
+    interface Context {
+        config: Config;
+        debug(...args: any[]): void;
+        error(message: Error | string, options?: {
+            code?: string;
+            exit?: number;
+        }): void;
+        exit(code?: number): void;
+        log(message?: any, ...args: any[]): void;
+        warn(message: string): void;
+    }
+    interface Result<T> {
+        failures: Array<{
+            error: Error;
+            plugin: Plugin;
+        }>;
+        successes: Array<{
+            plugin: Plugin;
+            result: T;
+        }>;
+    }
+}
+export {};

node_modules/@oclif/core/lib/interfaces/hooks.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

node_modules/@oclif/core/lib/interfaces/index.d.ts

@@ -0,0 +1,16 @@
+export type { AlphabetLowercase, AlphabetUppercase } from './alphabet';
+export type { InferredArgs } from './args';
+export type { ArchTypes, Config, LoadOptions, PlatformTypes, PluginVersionDetail, VersionDetails } from './config';
+export type { CommandError, OclifError, PrettyPrintableError } from './errors';
+export type { InferredFlags } from './flags';
+export type { HelpOptions } from './help';
+export type { Hook, Hooks } from './hooks';
+export type { Logger } from './logger';
+export type { Manifest } from './manifest';
+export type { Arg, ArgDefinition, ArgInput, BooleanFlag, CustomOptions, Deprecation, Flag, FlagDefinition, FlagInput, Input, OptionFlag, OutputArgs, OutputFlags, ParserOutput, } from './parser';
+export type { LinkedPlugin, OclifConfiguration, PJSON, S3, S3Templates, UserPJSON, UserPlugin } from './pjson';
+export type { Options, Plugin, PluginOptions } from './plugin';
+export type { S3Manifest } from './s3-manifest';
+export type { Theme } from './theme';
+export type { Topic } from './topic';
+export type { TSConfig } from './ts-config';

node_modules/@oclif/core/lib/interfaces/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

node_modules/@oclif/core/lib/interfaces/logger.d.ts

@@ -0,0 +1,9 @@
+export type Logger = {
+    debug: (formatter: unknown, ...args: unknown[]) => void;
+    error: (formatter: unknown, ...args: unknown[]) => void;
+    info: (formatter: unknown, ...args: unknown[]) => void;
+    trace: (formatter: unknown, ...args: unknown[]) => void;
+    warn: (formatter: unknown, ...args: unknown[]) => void;
+    child: (namespace: string) => Logger;
+    namespace: string;
+};

node_modules/@oclif/core/lib/interfaces/logger.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

node_modules/@oclif/core/lib/interfaces/manifest.d.ts

@@ -0,0 +1,7 @@
+import { Command } from '../command';
+export type Manifest = {
+    commands: {
+        [id: string]: Command.Cached;
+    };
+    version: string;
+};

node_modules/@oclif/core/lib/interfaces/manifest.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

node_modules/@oclif/core/lib/interfaces/parser.d.ts

@@ -0,0 +1,467 @@
+import { Command } from '../command';
+import { AlphabetLowercase, AlphabetUppercase } from './alphabet';
+export type FlagOutput = {
+    [name: string]: any;
+};
+export type ArgOutput = {
+    [name: string]: any;
+};
+export type CLIParseErrorOptions = {
+    parse: {
+        input?: ParserInput | undefined;
+        output?: ParserOutput | undefined;
+    };
+    exit?: number | undefined;
+};
+export type OutputArgs<T extends ParserInput['args']> = {
+    [P in keyof T]: any;
+};
+export type OutputFlags<T extends ParserInput['flags']> = {
+    [P in keyof T]: any;
+};
+export type ParserOutput<TFlags extends OutputFlags<any> = any, BFlags extends OutputFlags<any> = any, TArgs extends OutputFlags<any> = any> = {
+    flags: TFlags & BFlags & {
+        json: boolean | undefined;
+    };
+    args: TArgs;
+    argv: unknown[];
+    raw: ParsingToken[];
+    metadata: Metadata;
+    nonExistentFlags: string[];
+};
+export type ArgToken = {
+    type: 'arg';
+    arg: string;
+    input: string;
+};
+export type FlagToken = {
+    type: 'flag';
+    flag: string;
+    input: string;
+};
+export type ParsingToken = ArgToken | FlagToken;
+export type FlagUsageOptions = {
+    displayRequired?: boolean;
+};
+export type Metadata = {
+    flags: {
+        [key: string]: MetadataFlag;
+    };
+};
+export type MetadataFlag = {
+    setFromDefault?: boolean;
+    defaultHelp?: unknown;
+};
+export type ListItem = [string, string | undefined];
+export type List = ListItem[];
+export type CustomOptions = Record<string, unknown>;
+export type DefaultContext<T> = {
+    options: T;
+    flags: Record<string, string>;
+};
+/**
+ * Type to define a default value for a flag.
+ * @param context The context of the flag.
+ */
+export type FlagDefault<T, P = CustomOptions> = T | ((context: DefaultContext<P & OptionFlag<T, P>>) => Promise<T>);
+/**
+ * Type to define a defaultHelp value for a flag.
+ * The defaultHelp value is used in the help output for the flag and when writing a manifest.
+ * It is also can be used to provide a value for the flag when issuing certain error messages.
+ *
+ * @param context The context of the flag.
+ */
+export type FlagDefaultHelp<T, P = CustomOptions> = T | ((context: DefaultContext<P & OptionFlag<T, P>>) => Promise<string | undefined>);
+/**
+ * Type to define a default value for an arg.
+ * @param context The context of the arg.
+ */
+export type ArgDefault<T, P = CustomOptions> = T | ((context: DefaultContext<Arg<T, P>>) => Promise<T>);
+/**
+ * Type to define a defaultHelp value for an arg.
+ * @param context The context of the arg.
+ */
+export type ArgDefaultHelp<T, P = CustomOptions> = T | ((context: DefaultContext<Arg<T, P>>) => Promise<string | undefined>);
+export type FlagRelationship = string | {
+    name: string;
+    when: (flags: Record<string, unknown>) => Promise<boolean>;
+};
+export type Relationship = {
+    type: 'all' | 'some' | 'none' | 'only';
+    flags: FlagRelationship[];
+};
+export type Deprecation = {
+    to?: string;
+    message?: string;
+    version?: string | number;
+};
+export type FlagProps = {
+    name: string;
+    char?: AlphabetLowercase | AlphabetUppercase;
+    /**
+     * A short summary of flag usage to show in the flag list.
+     * If not provided, description will be used.
+     */
+    summary?: string;
+    /**
+     * A description of flag usage. If summary is provided, the description
+     * is assumed to be a longer description and will be shown in a separate
+     * section within help.
+     */
+    description?: string;
+    /**
+     * The flag label to show in help. Defaults to "[-<char>] --<name>" where -<char> is
+     * only displayed if the char is defined.
+     */
+    helpLabel?: string;
+    /**
+     * Shows this flag in a separate list in the help.
+     */
+    helpGroup?: string;
+    /**
+     * Accept an environment variable as input
+     */
+    env?: string;
+    /**
+     * If true, the flag will not be shown in the help.
+     */
+    hidden?: boolean;
+    /**
+     * If true, the flag will be required.
+     */
+    required?: boolean;
+    /**
+     * List of flags that this flag depends on.
+     */
+    dependsOn?: string[];
+    /**
+     * List of flags that cannot be used with this flag.
+     */
+    exclusive?: string[];
+    /**
+     * List of the only flags that can be used with this flag.
+     */
+    combinable?: string[];
+    /**
+     * Exactly one of these flags must be provided.
+     */
+    exactlyOne?: string[];
+    /**
+     * Define complex relationships between flags.
+     */
+    relationships?: Relationship[];
+    /**
+     * Make the flag as deprecated.
+     */
+    deprecated?: true | Deprecation;
+    /**
+     * Alternate names that can be used for this flag.
+     */
+    aliases?: string[];
+    /**
+     * Alternate short chars that can be used for this flag.
+     */
+    charAliases?: (AlphabetLowercase | AlphabetUppercase)[];
+    /**
+     * Emit deprecation warning when a flag alias is provided
+     */
+    deprecateAliases?: boolean;
+    /**
+     * If true, the value returned by defaultHelp will not be cached in the oclif.manifest.json.
+     * This is helpful if the default value contains sensitive data that shouldn't be published to npm.
+     */
+    noCacheDefault?: boolean;
+    /**
+     * At least one of these flags must be provided.
+     */
+    atLeastOne?: string[];
+};
+export type ArgProps = {
+    name: string;
+    /**
+     * A description of flag usage. If summary is provided, the description
+     * is assumed to be a longer description and will be shown in a separate
+     * section within help.
+     */
+    description?: string;
+    /**
+     * If true, the flag will not be shown in the help.
+     */
+    hidden?: boolean;
+    /**
+     * If true, the flag will be required.
+     */
+    required?: boolean;
+    options?: string[];
+    ignoreStdin?: boolean;
+    /**
+     * If true, the value returned by defaultHelp will not be cached in the oclif.manifest.json.
+     * This is helpful if the default value contains sensitive data that shouldn't be published to npm.
+     */
+    noCacheDefault?: boolean;
+};
+export type BooleanFlagProps = FlagProps & {
+    type: 'boolean';
+    allowNo: boolean;
+};
+export type OptionFlagProps = FlagProps & {
+    type: 'option';
+    helpValue?: string | string[];
+    options?: readonly string[];
+    multiple?: boolean;
+    /**
+     * Parse one value per flag; allow `-m val1 -m val2`, disallow `-m val1 val2`.
+     * Set to true to use "multiple: true" flags together with args.
+     * Only respected if multiple is set to true.
+     */
+    multipleNonGreedy?: boolean;
+    /**
+     * Delimiter to separate the values for a multiple value flag.
+     * Only respected if multiple is set to true. Default behavior is to
+     * separate on spaces.
+     */
+    delimiter?: ',';
+    /**
+     * Allow input value to be read from stdin if the provided value is `-`.
+     * If set to `only`, the flag will only accept input from stdin.
+     * Should only be used on one flag at a time.
+     */
+    allowStdin?: boolean | 'only';
+};
+export type FlagParserContext = Command & {
+    token: FlagToken;
+};
+type NonNullableElementOf<T> = [NonNullable<T>] extends [Array<infer U>] ? U : T;
+export type FlagParser<T, I extends string | boolean, P = CustomOptions> = (input: I, context: FlagParserContext, opts: P & OptionFlag<T, P>) => Promise<NonNullableElementOf<T> | undefined>;
+export type ArgParserContext = Command & {
+    token: ArgToken;
+};
+export type ArgParser<T, P = CustomOptions> = (input: string, context: ArgParserContext, opts: P & Arg<T, P>) => Promise<T>;
+export type Arg<T, P = CustomOptions> = ArgProps & {
+    options?: T[];
+    defaultHelp?: ArgDefaultHelp<T>;
+    input: string[];
+    default?: ArgDefault<T | undefined>;
+    parse: ArgParser<T, P>;
+};
+export type ArgDefinition<T, P = CustomOptions> = {
+    (options: P & ({
+        required: true;
+    } | {
+        default: ArgDefault<T>;
+    }) & Partial<Arg<T, P>>): Arg<T, P>;
+    (options?: P & Partial<Arg<T, P>>): Arg<T | undefined, P>;
+};
+export type BooleanFlag<T> = FlagProps & BooleanFlagProps & {
+    /**
+     * specifying a default of false is the same as not specifying a default
+     */
+    default?: FlagDefault<boolean>;
+    parse: (input: boolean, context: FlagParserContext, opts: FlagProps & BooleanFlagProps) => Promise<T>;
+};
+export type OptionFlag<T, P = CustomOptions> = FlagProps & OptionFlagProps & {
+    parse: FlagParser<T | undefined, string, P>;
+    defaultHelp?: FlagDefaultHelp<T, P>;
+    input: string[];
+    default?: FlagDefault<T | undefined, P>;
+};
+type ReturnTypeSwitches = {
+    multiple: boolean;
+    requiredOrDefaulted: boolean;
+};
+/**
+ * The logic here is as follows:
+ * - If requiredOrDefaulted is true && multiple is true, then the return type is T[]
+ *    - It's possible that T extends an Array, if so we want to return T so that the return isn't T[][]
+ * - If requiredOrDefaulted is true && multiple is false, then the return type is T
+ * - If requiredOrDefaulted is false && multiple is true, then the return type is T[] | undefined
+ *    - It's possible that T extends an Array, if so we want to return T so that the return isn't T[][]
+ * - If requiredOrDefaulted is false && multiple is false, then the return type is T | undefined
+ */
+type FlagReturnType<T, R extends ReturnTypeSwitches> = R['requiredOrDefaulted'] extends true ? R['multiple'] extends true ? [T] extends [Array<unknown>] ? T : T[] : T : R['multiple'] extends true ? [T] extends [Array<unknown>] ? T | undefined : T[] | undefined : T | undefined;
+/**
+ * FlagDefinition types a function that takes `options` and returns an OptionFlag<T>.
+ *
+ * This is returned by `Flags.custom()` and `Flags.option()`, which each take a `defaults` object
+ * that mirrors the OptionFlag interface.
+ *
+ * The `T` in the `OptionFlag<T>` return type is determined by a combination of the provided defaults for
+ * `multiple`, `required`, and `default` and the provided options for those same properties. If these properties
+ * are provided in the options, they override the defaults.
+ *
+ * no options or defaults -> T | undefined
+ * `required` -> T
+ * `default` -> T
+ * `multiple` -> T[] | undefined
+ * `required` + `multiple` -> T[]
+ * `default` + `multiple` -> T[]
+ */
+export type FlagDefinition<T, P = CustomOptions, R extends ReturnTypeSwitches = {
+    multiple: false;
+    requiredOrDefaulted: false;
+}> = {
+    (options: P & {
+        multiple: false;
+        required: true;
+    } & Partial<OptionFlag<FlagReturnType<T, {
+        multiple: false;
+        requiredOrDefaulted: true;
+    }>, P>>): OptionFlag<FlagReturnType<T, {
+        multiple: false;
+        requiredOrDefaulted: true;
+    }>>;
+    (options: P & {
+        multiple: true;
+        required: false;
+    } & Partial<OptionFlag<FlagReturnType<T, {
+        multiple: true;
+        requiredOrDefaulted: false;
+    }>, P>>): OptionFlag<FlagReturnType<T, {
+        multiple: true;
+        requiredOrDefaulted: false;
+    }>>;
+    (options: P & {
+        multiple: false;
+        required: false;
+    } & Partial<OptionFlag<FlagReturnType<T, {
+        multiple: false;
+        requiredOrDefaulted: false;
+    }>, P>>): OptionFlag<FlagReturnType<T, {
+        multiple: false;
+        requiredOrDefaulted: false;
+    }>>;
+    (options: R['multiple'] extends true ? // `multiple` is defaulted to true and either `required=true` or `default` are provided in options
+    P & ({
+        required: true;
+    } | {
+        default: OptionFlag<FlagReturnType<T, {
+            multiple: R['multiple'];
+            requiredOrDefaulted: true;
+        }>, P>['default'];
+    }) & Partial<OptionFlag<FlagReturnType<T, {
+        multiple: R['multiple'];
+        requiredOrDefaulted: true;
+    }>, P>> : // `multiple` is NOT defaulted to true and either `required=true` or `default` are provided in options
+    P & {
+        multiple?: false | undefined;
+    } & ({
+        required: true;
+    } | {
+        default: OptionFlag<FlagReturnType<T, {
+            multiple: R['multiple'];
+            requiredOrDefaulted: true;
+        }>, P>['default'];
+    }) & Partial<OptionFlag<FlagReturnType<T, {
+        multiple: R['multiple'];
+        requiredOrDefaulted: true;
+    }>, P>>): OptionFlag<FlagReturnType<T, {
+        multiple: R['multiple'];
+        requiredOrDefaulted: true;
+    }>>;
+    (options: R['multiple'] extends true ? // `multiple` is defaulted to true and either `required=true` or `default` are provided in options
+    P & ({
+        required: true;
+    } | {
+        default: OptionFlag<FlagReturnType<T, {
+            multiple: true;
+            requiredOrDefaulted: true;
+        }>, P>['default'];
+    }) & Partial<OptionFlag<FlagReturnType<T, {
+        multiple: true;
+        requiredOrDefaulted: true;
+    }>, P>> : // `multiple` is NOT defaulted to true but `multiple=true` and either `required=true` or `default` are provided in options
+    P & {
+        multiple: true;
+    } & ({
+        required: true;
+    } | {
+        default: OptionFlag<FlagReturnType<T, {
+            multiple: true;
+            requiredOrDefaulted: true;
+        }>, P>['default'];
+    }) & Partial<OptionFlag<FlagReturnType<T, {
+        multiple: true;
+        requiredOrDefaulted: true;
+    }>, P>>): OptionFlag<FlagReturnType<T, {
+        multiple: true;
+        requiredOrDefaulted: true;
+    }>>;
+    (options: P & {
+        multiple?: false | undefined;
+    } & ({
+        required: true;
+    } | {
+        default: OptionFlag<FlagReturnType<T, {
+            multiple: R['multiple'];
+            requiredOrDefaulted: true;
+        }>, P>['default'];
+    }) & Partial<OptionFlag<FlagReturnType<T, {
+        multiple: R['multiple'];
+        requiredOrDefaulted: true;
+    }>, P>>): OptionFlag<FlagReturnType<T, {
+        multiple: R['multiple'];
+        requiredOrDefaulted: true;
+    }>>;
+    (options: P & {
+        required: false;
+    } & Partial<OptionFlag<FlagReturnType<T, {
+        multiple: R['multiple'];
+        requiredOrDefaulted: false;
+    }>, P>>): OptionFlag<FlagReturnType<T, {
+        multiple: R['multiple'];
+        requiredOrDefaulted: false;
+    }>>;
+    (options: P & {
+        multiple: false;
+    } & Partial<OptionFlag<FlagReturnType<T, {
+        multiple: false;
+        requiredOrDefaulted: R['requiredOrDefaulted'];
+    }>, P>>): OptionFlag<FlagReturnType<T, {
+        multiple: false;
+        requiredOrDefaulted: R['requiredOrDefaulted'];
+    }>>;
+    (options?: P & {
+        multiple?: false | undefined;
+    } & Partial<OptionFlag<FlagReturnType<T, R>, P>>): OptionFlag<FlagReturnType<T, R>>;
+    (options: P & {
+        multiple: true;
+    } & Partial<OptionFlag<FlagReturnType<T, {
+        multiple: true;
+        requiredOrDefaulted: R['requiredOrDefaulted'];
+    }>, P>>): OptionFlag<FlagReturnType<T, {
+        multiple: true;
+        requiredOrDefaulted: R['requiredOrDefaulted'];
+    }>>;
+};
+export type Flag<T> = BooleanFlag<T> | OptionFlag<T>;
+export type Input<TFlags extends FlagOutput, BFlags extends FlagOutput, AFlags extends ArgOutput> = {
+    flags?: FlagInput<TFlags>;
+    baseFlags?: FlagInput<BFlags>;
+    enableJsonFlag?: true | false;
+    args?: ArgInput<AFlags>;
+    strict?: boolean | undefined;
+    context?: ParserContext;
+    '--'?: boolean;
+};
+export type ParserInput = {
+    argv: string[];
+    flags: FlagInput<any>;
+    args: ArgInput<any>;
+    strict: boolean;
+    context: ParserContext | undefined;
+    '--'?: boolean | undefined;
+};
+export type ParserContext = Command & {
+    token?: FlagToken | ArgToken | undefined;
+};
+export type FlagInput<T extends FlagOutput = {
+    [flag: string]: any;
+}> = {
+    [P in keyof T]: Flag<T[P]>;
+};
+export type ArgInput<T extends ArgOutput = {
+    [arg: string]: any;
+}> = {
+    [P in keyof T]: Arg<T[P]>;
+};
+export {};

node_modules/@oclif/core/lib/interfaces/parser.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

node_modules/@oclif/core/lib/interfaces/pjson.d.ts

@@ -0,0 +1,313 @@
+import { HelpOptions } from './help';
+import { Theme } from './theme';
+export type CommandDiscovery = {
+    /**
+     * The strategy to use for loading commands.
+     *
+     * - `pattern` will use glob patterns to find command files in the specified `target`.
+     * - `explicit` will use `import` (or `require` for CJS) to load the commands from the
+     *    specified `target`.
+     * - `single` will use the `target` which should export a command class. This is for CLIs that
+     *    only have a single command.
+     *
+     * In both cases, the `oclif.manifest.json` file will be used to find the commands if it exists.
+     */
+    strategy: 'pattern' | 'explicit' | 'single';
+    /**
+     * If the `strategy` is `pattern`, this is the **directory** to use to find command files.
+     *
+     * If the `strategy` is `explicit`, this is the **file** that exports the commands.
+     *   - This export must be an object with keys that are the command names and values that are the command classes.
+     *   - Unless `identifier` is specified, the default export will be used.
+     *
+     * @example
+     * ```typescript
+     * // in src/commands.ts
+     * import {Command} from '@oclif/core'
+     * import Hello from './commands/hello/index.js'
+     * import HelloWorld from './commands/hello/world.js'
+     *
+     * export default {
+     *   hello: Hello,
+     *   'hello:world': HelloWorld,
+     * } satisfies Record<string, Command.Class>
+     * ```
+     */
+    target: string;
+    /**
+     * The glob patterns to use to find command files when no `oclif.manifest.json` is present.
+     * This is only used when `strategy` is `pattern`.
+     */
+    globPatterns?: string[];
+    /**
+     * The name of the export to used when loading the command object from the `target` file. Only
+     * used when `strategy` is `explicit`. Defaults to `default`.
+     *
+     * @example
+     * ```typescript
+     * // in src/commands.ts
+     * import {Command} from '@oclif/core'
+     * import Hello from './commands/hello/index.js'
+     * import HelloWorld from './commands/hello/world.js'
+     *
+     * export const MY_COMMANDS = {
+     *  hello: Hello,
+     * 'hello:world': HelloWorld,
+     * } satisfies Record<string, Command.Class>
+     * ```
+     *
+     * In the package.json:
+     * ```json
+     * {
+     *  "oclif": {
+     *   "commands": {
+     *     "strategy": "explicit",
+     *     "target": "./dist/index.js",
+     *     "identifier": "MY_COMMANDS"
+     *    }
+     * }
+     * ```
+     */
+    identifier?: string;
+};
+export type HookOptions = {
+    /**
+     * The file path containing hook.
+     */
+    target: string;
+    /**
+     * The name of the export to use when loading the hook function from the `target` file. Defaults to `default`.
+     */
+    identifier: string;
+};
+export type HelpLocationOptions = {
+    /**
+     * The file path containing help class.
+     */
+    target: string;
+    /**
+     * The name of the export to use when loading the help class from the `target` file. Defaults to `default`.
+     */
+    identifier: string;
+};
+export type S3Templates = {
+    baseDir?: string;
+    manifest?: string;
+    unversioned?: string;
+    versioned?: string;
+};
+export type S3 = {
+    acl?: string | undefined;
+    bucket?: string | undefined;
+    folder?: string | undefined;
+    gz?: boolean | undefined;
+    host?: string | undefined;
+    indexVersionLimit?: number | undefined;
+    templates?: {
+        target: S3Templates;
+        vanilla: S3Templates;
+    } | undefined;
+    xz?: boolean | undefined;
+};
+export type OclifConfiguration = {
+    /**
+     * Flags in addition to --help that should trigger help output.
+     */
+    additionalHelpFlags?: string[];
+    /**
+     * Flags in addition to --version that should trigger version output.
+     */
+    additionalVersionFlags?: string[];
+    /**
+     * Plugin aliases.
+     */
+    aliases?: {
+        [name: string]: null | string;
+    };
+    /**
+     * The name of the executable.
+     */
+    bin?: string;
+    /**
+     * Aliases for the executable.
+     */
+    binAliases?: string[];
+    commands?: string | CommandDiscovery;
+    /**
+     * Your CLI's description. Overrides the description in the package.json.
+     */
+    description?: string | undefined;
+    /**
+     * Plugins to load when in development mode.
+     */
+    devPlugins?: string[];
+    /**
+     * The directory name to use when determining the cache, config, and data directories.
+     */
+    dirname?: string;
+    /**
+     * Example plugin to use in @oclif/plugin-plugin's help output.
+     */
+    examplePlugin?: string;
+    /**
+     * Customize the exit codes for the CLI.
+     */
+    exitCodes?: {
+        default?: number;
+        failedFlagParsing?: number;
+        failedFlagValidation?: number;
+        invalidArgsSpec?: number;
+        nonExistentFlag?: number;
+        requiredArgs?: number;
+        unexpectedArgs?: number;
+    };
+    /**
+     * Enable flexible taxonomy for commands.
+     */
+    flexibleTaxonomy?: boolean;
+    /**
+     * The location of your custom help class.
+     */
+    helpClass?: string | HelpLocationOptions;
+    /**
+     * Options for the help output.
+     */
+    helpOptions?: HelpOptions;
+    /**
+     * Register hooks to run at various points in the CLI lifecycle.
+     */
+    hooks?: {
+        [name: string]: string | string[] | HookOptions | HookOptions[] | (string | HookOptions)[];
+    };
+    /**
+     * Plugins that can be installed just-in-time.
+     */
+    jitPlugins?: Record<string, string>;
+    macos?: {
+        identifier?: string;
+        sign?: string;
+    };
+    /**
+     * Use a private or alternate npm registry.
+     */
+    npmRegistry?: string;
+    /**
+     * Script to run during postinstall on windows.
+     */
+    nsisCustomization?: string;
+    /**
+     * Plugin prefix to use when working with plugins with @oclif/plugin-plugins.
+     *
+     * Defaults to `plugin-`.
+     */
+    pluginPrefix?: string;
+    /**
+     * Plugins to load.
+     */
+    plugins?: string[];
+    /**
+     * Template string used to build links to source code in CLI's README (when using `oclif readme`).
+     */
+    repositoryPrefix?: string;
+    schema?: number;
+    /**
+     * The namespace to be used for plugins of your CLI, e.g. `@salesforce`.
+     */
+    scope?: string;
+    /**
+     * State of your CLI
+     *
+     * - `beta` - will show message to user that command or CLI is in beta
+     * - `deprecated` - will show message to user that command or CLI is deprecated
+     */
+    state?: 'beta' | 'deprecated' | string;
+    /**
+     * The theme to ship with the CLI.
+     *
+     * Can be a path to a JSON file or a Theme object.
+     */
+    theme?: string | Theme;
+    /**
+     * Separator to use for your CLI. Can be `:` or ` `.
+     */
+    topicSeparator?: ' ' | ':';
+    /**
+     * Customize the topics in the CLI.
+     */
+    topics?: {
+        [k: string]: {
+            description?: string;
+            hidden?: boolean;
+            subtopics?: OclifConfiguration['topics'];
+        };
+    };
+    /**
+     * Tar flags configuration for different platforms.
+     *
+     * {
+     *  "tarFlags": {
+     *   "win32": "--force-local",
+     *   "darwin": "--no-xattrs"
+     *  }
+     * }
+     *
+     */
+    tarFlags?: {
+        [platform: string]: string;
+    };
+    update?: {
+        autoupdate?: {
+            debounce?: number;
+            rollout?: number;
+        };
+        disableNpmLookup?: boolean;
+        node?: {
+            targets?: string[];
+            version?: string;
+            options?: string | string[];
+        };
+        s3?: S3;
+    };
+    'warn-if-update-available'?: {
+        authorization?: string;
+        message?: string;
+        registry?: string;
+        timeoutInDays?: number;
+        frequency?: number;
+        frequencyUnit?: 'days' | 'hours' | 'minutes' | 'seconds' | 'milliseconds';
+    };
+    windows?: {
+        homepage?: string;
+        keypath?: string;
+        name?: string;
+    };
+};
+export type UserPlugin = {
+    name: string;
+    tag?: string;
+    type: 'user';
+    url?: string;
+};
+export type LinkedPlugin = {
+    name: string;
+    root: string;
+    type: 'link';
+};
+export type UserPJSON = {
+    oclif: {
+        plugins?: (UserPlugin | LinkedPlugin)[];
+    };
+    private?: boolean;
+};
+export type PJSON = {
+    [k: string]: any;
+    dependencies?: {
+        [name: string]: string;
+    };
+    devDependencies?: {
+        [name: string]: string;
+    };
+    name: string;
+    oclif: OclifConfiguration;
+    version: string;
+};

node_modules/@oclif/core/lib/interfaces/pjson.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

node_modules/@oclif/core/lib/interfaces/plugin.d.ts

@@ -0,0 +1,104 @@
+import { Command } from '../command';
+import { Logger } from './logger';
+import { HookOptions, PJSON } from './pjson';
+import { Topic } from './topic';
+export interface PluginOptions {
+    children?: Plugin[] | undefined;
+    errorOnManifestCreate?: boolean | undefined;
+    flexibleTaxonomy?: boolean | undefined;
+    ignoreManifest?: boolean | undefined;
+    isRoot?: boolean | undefined;
+    name?: string | undefined;
+    parent?: Plugin | undefined;
+    pjson?: PJSON | undefined;
+    respectNoCacheDefault?: boolean | undefined;
+    root: string;
+    tag?: string | undefined;
+    type?: string | undefined;
+    url?: string | undefined;
+}
+export interface Options extends PluginOptions {
+    channel?: string | undefined;
+    devPlugins?: boolean | undefined;
+    enablePerf?: boolean | undefined;
+    jitPlugins?: boolean | undefined;
+    logger?: Logger | undefined;
+    pjson?: PJSON | undefined;
+    pluginAdditions?: {
+        core?: string[];
+        dev?: string[];
+        path?: string;
+    } | undefined;
+    plugins?: Map<string, Plugin> | undefined;
+    userPlugins?: boolean | undefined;
+    version?: string | undefined;
+}
+export interface Plugin {
+    /**
+     * ../config version
+     */
+    _base: string;
+    /**
+     * aliases from package.json dependencies
+     */
+    alias: string;
+    readonly commandIDs: string[];
+    commands: Command.Loadable[];
+    readonly commandsDir: string | undefined;
+    findCommand(id: string, opts: {
+        must: true;
+    }): Promise<Command.Class>;
+    findCommand(id: string, opts?: {
+        must: boolean;
+    }): Promise<Command.Class> | undefined;
+    readonly hasManifest: boolean;
+    hooks: {
+        [key: string]: HookOptions[];
+    };
+    /**
+     * True if the plugin is the root plugin.
+     */
+    isRoot: boolean;
+    load(): Promise<void>;
+    /**
+     * Plugin is written in ESM or CommonJS
+     */
+    moduleType: 'commonjs' | 'module';
+    /**
+     * name from package.json
+     */
+    name: string;
+    readonly options: Options;
+    parent?: Plugin | undefined;
+    /**
+     * full package.json
+     *
+     * parsed with read-pkg
+     */
+    pjson: PJSON;
+    /**
+     * base path of plugin
+     */
+    root: string;
+    /**
+     * npm dist-tag of plugin
+     * only used for user plugins
+     */
+    tag?: string | undefined;
+    readonly topics: Topic[];
+    /**
+     * used to tell the user how the plugin was installed
+     * examples: core, link, user, dev
+     */
+    type: string;
+    /**
+     * if it appears to be an npm package but does not look like it's really a CLI plugin, this is set to false
+     */
+    valid: boolean;
+    /**
+     * version from package.json
+     *
+     * example: 1.2.3
+     */
+    version: string;
+}

node_modules/@oclif/core/lib/interfaces/plugin.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

node_modules/@oclif/core/lib/interfaces/s3-manifest.d.ts

@@ -0,0 +1,14 @@
+export interface S3Manifest {
+    baseDir: string;
+    gz: string;
+    node: {
+        compatible: string;
+        recommended: string;
+    };
+    rollout?: number;
+    sha: string;
+    sha256gz: string;
+    sha256xz?: string;
+    version: string;
+    xz?: string;
+}

node_modules/@oclif/core/lib/interfaces/s3-manifest.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

node_modules/@oclif/core/lib/interfaces/theme.d.ts

@@ -0,0 +1,32 @@
+export declare const STANDARD_ANSI: readonly ["white", "black", "blue", "yellow", "green", "red", "magenta", "cyan", "gray", "blackBright", "redBright", "greenBright", "yellowBright", "blueBright", "magentaBright", "cyanBright", "whiteBright", "bgBlack", "bgRed", "bgGreen", "bgYellow", "bgBlue", "bgMagenta", "bgCyan", "bgWhite", "bgGray", "bgBlackBright", "bgRedBright", "bgGreenBright", "bgYellowBright", "bgBlueBright", "bgMagentaBright", "bgCyanBright", "bgWhiteBright", "bold", "underline", "dim", "italic", "strikethrough"];
+export type StandardAnsi = (typeof STANDARD_ANSI)[number];
+export type JsonTheme = {
+    brace?: string | StandardAnsi;
+    bracket?: string | StandardAnsi;
+    colon?: string | StandardAnsi;
+    comma?: string | StandardAnsi;
+    key?: string | StandardAnsi;
+    string?: string | StandardAnsi;
+    number?: string | StandardAnsi;
+    boolean?: string | StandardAnsi;
+    null?: string | StandardAnsi;
+};
+export type Theme = {
+    [key: string]: string | StandardAnsi | Theme | undefined;
+    alias?: string | StandardAnsi;
+    bin?: string | StandardAnsi;
+    command?: string | StandardAnsi;
+    commandSummary?: string | StandardAnsi;
+    dollarSign?: string | StandardAnsi;
+    flag?: string | StandardAnsi;
+    flagDefaultValue?: string | StandardAnsi;
+    flagOptions?: string | StandardAnsi;
+    flagRequired?: string | StandardAnsi;
+    flagSeparator?: string | StandardAnsi;
+    json?: JsonTheme;
+    sectionDescription?: string | StandardAnsi;
+    sectionHeader?: string | StandardAnsi;
+    spinner?: string | StandardAnsi;
+    topic?: string | StandardAnsi;
+    version?: string | StandardAnsi;
+};

node_modules/@oclif/core/lib/interfaces/theme.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STANDARD_ANSI = void 0;
+exports.STANDARD_ANSI = [
+    'white',
+    'black',
+    'blue',
+    'yellow',
+    'green',
+    'red',
+    'magenta',
+    'cyan',
+    'gray',
+    'blackBright',
+    'redBright',
+    'greenBright',
+    'yellowBright',
+    'blueBright',
+    'magentaBright',
+    'cyanBright',
+    'whiteBright',
+    'bgBlack',
+    'bgRed',
+    'bgGreen',
+    'bgYellow',
+    'bgBlue',
+    'bgMagenta',
+    'bgCyan',
+    'bgWhite',
+    'bgGray',
+    'bgBlackBright',
+    'bgRedBright',
+    'bgGreenBright',
+    'bgYellowBright',
+    'bgBlueBright',
+    'bgMagentaBright',
+    'bgCyanBright',
+    'bgWhiteBright',
+    'bold',
+    'underline',
+    'dim',
+    'italic',
+    'strikethrough',
+];

node_modules/@oclif/core/lib/interfaces/topic.d.ts

@@ -0,0 +1,5 @@
+export interface Topic {
+    description?: string | undefined;
+    hidden?: boolean | undefined;
+    name: string;
+}

node_modules/@oclif/core/lib/interfaces/topic.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

node_modules/@oclif/core/lib/interfaces/ts-config.d.ts

@@ -0,0 +1,23 @@
+export interface TSConfig {
+    compilerOptions: {
+        baseUrl?: string;
+        emitDecoratorMetadata?: boolean;
+        esModuleInterop?: boolean;
+        experimentalDecorators?: boolean;
+        jsx?: boolean;
+        module?: string;
+        moduleResolution?: string;
+        outDir?: string;
+        rootDir?: string;
+        rootDirs?: string[];
+        sourceMap?: boolean;
+        target?: string;
+    };
+    extends?: string;
+    'ts-node'?: {
+        esm?: boolean;
+        experimentalSpecifierResolution?: 'explicit' | 'node';
+        scope?: boolean;
+        swc?: boolean;
+    };
+}

node_modules/@oclif/core/lib/interfaces/ts-config.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

node_modules/@oclif/core/lib/logger.d.ts

@@ -0,0 +1,14 @@
+import { LoadOptions } from './interfaces/config';
+import { Logger } from './interfaces/logger';
+/**
+ * Returns a logger instance for the given namespace.
+ * If a namespace is provided, a child logger is returned.
+ * If no namespace is provided, the root logger is returned.
+ */
+export declare function getLogger(namespace?: string): Logger;
+/**
+ * Convenience function to create a debug function for a specific namespace
+ */
+export declare function makeDebug(namespace: string): Logger['debug'];
+export declare function setLogger(loadOptions: LoadOptions): void;
+export declare function clearLoggers(): void;

node_modules/@oclif/core/lib/logger.js

@@ -0,0 +1,89 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLogger = getLogger;
+exports.makeDebug = makeDebug;
+exports.setLogger = setLogger;
+exports.clearLoggers = clearLoggers;
+const debug_1 = __importDefault(require("debug"));
+const OCLIF_NS = 'oclif';
+function makeLogger(namespace = OCLIF_NS) {
+    const debug = (0, debug_1.default)(namespace);
+    return {
+        child: (ns, delimiter) => makeLogger(`${namespace}${delimiter ?? ':'}${ns}`),
+        debug,
+        error: (formatter, ...args) => makeLogger(`${namespace}:error`).debug(formatter, ...args),
+        info: debug,
+        namespace,
+        trace: debug,
+        warn: debug,
+    };
+}
+/**
+ * Cache of logger instances. This is used to prevent creating multiple logger instances for the same namespace.
+ *
+ * The root logger is stored under the 'root' key as well as it's namespace.
+ */
+const cachedLoggers = new Map();
+/**
+ * Returns a logger instance for the given namespace.
+ * If a namespace is provided, a child logger is returned.
+ * If no namespace is provided, the root logger is returned.
+ */
+function getLogger(namespace) {
+    let rootLogger = cachedLoggers.get('root');
+    if (!rootLogger) {
+        set(makeLogger(OCLIF_NS));
+    }
+    rootLogger = cachedLoggers.get('root');
+    if (namespace) {
+        const cachedLogger = cachedLoggers.get(namespace);
+        if (cachedLogger)
+            return cachedLogger;
+        const logger = rootLogger.child(namespace);
+        cachedLoggers.set(namespace, logger);
+        return logger;
+    }
+    return rootLogger;
+}
+function ensureItMatchesInterface(newLogger) {
+    return (typeof newLogger.child === 'function' &&
+        typeof newLogger.debug === 'function' &&
+        typeof newLogger.error === 'function' &&
+        typeof newLogger.info === 'function' &&
+        typeof newLogger.trace === 'function' &&
+        typeof newLogger.warn === 'function' &&
+        typeof newLogger.namespace === 'string');
+}
+function set(newLogger) {
+    if (cachedLoggers.has(newLogger.namespace))
+        return;
+    if (cachedLoggers.has('root'))
+        return;
+    if (ensureItMatchesInterface(newLogger)) {
+        cachedLoggers.set(newLogger.namespace, newLogger);
+        cachedLoggers.set('root', newLogger);
+    }
+    else {
+        process.emitWarning('Logger does not match the Logger interface. Using default logger.');
+    }
+}
+/**
+ * Convenience function to create a debug function for a specific namespace
+ */
+function makeDebug(namespace) {
+    return (formatter, ...args) => getLogger(namespace).debug(formatter, ...args);
+}
+function setLogger(loadOptions) {
+    if (loadOptions && typeof loadOptions !== 'string' && 'logger' in loadOptions && loadOptions.logger) {
+        set(loadOptions.logger);
+    }
+    else {
+        set(makeLogger(OCLIF_NS));
+    }
+}
+function clearLoggers() {
+    cachedLoggers.clear();
+}

node_modules/@oclif/core/lib/main.d.ts

@@ -0,0 +1,4 @@
+import * as Interfaces from './interfaces';
+export declare const helpAddition: (argv: string[], config: Interfaces.Config) => boolean;
+export declare const versionAddition: (argv: string[], config?: Interfaces.Config) => boolean;
+export declare function run(argv?: string[], options?: Interfaces.LoadOptions): Promise<unknown>;

node_modules/@oclif/core/lib/main.js

@@ -0,0 +1,106 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.versionAddition = exports.helpAddition = void 0;
+exports.run = run;
+const node_url_1 = require("node:url");
+const cache_1 = __importDefault(require("./cache"));
+const config_1 = require("./config");
+const help_1 = require("./help");
+const logger_1 = require("./logger");
+const performance_1 = require("./performance");
+const symbols_1 = require("./symbols");
+const ux_1 = require("./ux");
+const helpAddition = (argv, config) => {
+    if (argv.length === 0 && !config.isSingleCommandCLI)
+        return true;
+    const mergedHelpFlags = (0, help_1.getHelpFlagAdditions)(config);
+    for (const arg of argv) {
+        if (mergedHelpFlags.includes(arg))
+            return true;
+        if (arg === '--')
+            return false;
+    }
+    return false;
+};
+exports.helpAddition = helpAddition;
+const versionAddition = (argv, config) => {
+    const additionalVersionFlags = config?.pjson.oclif.additionalVersionFlags ?? [];
+    const mergedVersionFlags = [...new Set(['--version', ...additionalVersionFlags]).values()];
+    if (mergedVersionFlags.includes(argv[0]))
+        return true;
+    return false;
+};
+exports.versionAddition = versionAddition;
+async function run(argv, options) {
+    const marker = performance_1.Performance.mark(performance_1.OCLIF_MARKER_OWNER, 'main.run');
+    const initMarker = performance_1.Performance.mark(performance_1.OCLIF_MARKER_OWNER, 'main.run#init');
+    const showHelp = async (argv) => {
+        const Help = await (0, help_1.loadHelpClass)(config);
+        const help = new Help(config, config.pjson.oclif.helpOptions ?? config.pjson.helpOptions);
+        await help.showHelp(argv);
+    };
+    (0, logger_1.setLogger)(options);
+    const { debug } = (0, logger_1.getLogger)('main');
+    debug(`process.execPath: ${process.execPath}`);
+    debug(`process.execArgv: ${process.execArgv}`);
+    debug('process.argv: %O', process.argv);
+    argv = argv ?? process.argv.slice(2);
+    // Handle the case when a file URL string or URL is passed in such as 'import.meta.url'; covert to file path.
+    if (options && ((typeof options === 'string' && options.startsWith('file://')) || options instanceof node_url_1.URL)) {
+        options = (0, node_url_1.fileURLToPath)(options);
+    }
+    const config = await config_1.Config.load(options ?? require.main?.filename ?? __dirname);
+    cache_1.default.getInstance().set('config', config);
+    // If this is a single command CLI, then insert the SINGLE_COMMAND_CLI_SYMBOL into the argv array to serve as the command id.
+    if (config.isSingleCommandCLI) {
+        argv = [symbols_1.SINGLE_COMMAND_CLI_SYMBOL, ...argv];
+    }
+    const [id, ...argvSlice] = (0, help_1.normalizeArgv)(config, argv);
+    const runFinally = async (cmd, error) => {
+        marker?.stop();
+        if (!initMarker?.stopped)
+            initMarker?.stop();
+        await performance_1.Performance.collect();
+        performance_1.Performance.debug();
+        await config.runHook('finally', { argv: argvSlice, Command: cmd, error, id });
+    };
+    // run init hook
+    await config.runHook('init', { argv: argvSlice, id });
+    // display version if applicable
+    if ((0, exports.versionAddition)(argv, config)) {
+        ux_1.ux.stdout(config.userAgent);
+        await runFinally();
+        return;
+    }
+    // display help version if applicable
+    if ((0, exports.helpAddition)(argv, config)) {
+        await showHelp(argv);
+        await runFinally();
+        return;
+    }
+    // find & run command
+    const cmd = config.findCommand(id);
+    if (!cmd) {
+        const topic = config.flexibleTaxonomy ? null : config.findTopic(id);
+        if (topic) {
+            await showHelp([id]);
+            await runFinally();
+            return;
+        }
+    }
+    initMarker?.stop();
+    let err;
+    try {
+        return await config.runCommand(id, argvSlice, cmd);
+    }
+    catch (error) {
+        err = error;
+        throw error;
+    }
+    finally {
+        await runFinally(cmd, err);
+    }
+}

node_modules/@oclif/core/lib/module-loader.d.ts

@@ -0,0 +1,71 @@
+import { Command } from './command';
+import { Config as IConfig, Plugin as IPlugin } from './interfaces';
+/**
+ * Loads and returns a module.
+ *
+ * Uses `getPackageType` to determine if `type` is set to 'module. If so loads '.js' files as ESM otherwise uses
+ * a bare require to load as CJS. Also loads '.mjs' files as ESM.
+ *
+ * Uses dynamic import to load ESM source or require for CommonJS.
+ *
+ * A unique error, ModuleLoadError, combines both CJS and ESM loader module not found errors into a single error that
+ * provides a consistent stack trace and info.
+ *
+ * @param {IConfig|IPlugin} config - Oclif config or plugin config.
+ * @param {string} modulePath - NPM module name or file path to load.
+ *
+ * @returns {Promise<*>} The entire ESM module from dynamic import or CJS module by require.
+ */
+export declare function load<T = any>(config: IConfig | IPlugin, modulePath: string): Promise<T>;
+/**
+ * Loads a module and returns an object with the module and data about the module.
+ *
+ * Uses `getPackageType` to determine if `type` is set to `module`. If so loads '.js' files as ESM otherwise uses
+ * a bare require to load as CJS. Also loads '.mjs' files as ESM.
+ *
+ * Uses dynamic import to load ESM source or require for CommonJS.
+ *
+ * A unique error, ModuleLoadError, combines both CJS and ESM loader module not found errors into a single error that
+ * provides a consistent stack trace and info.
+ *
+ * @param {IConfig|IPlugin} config - Oclif config or plugin config.
+ * @param {string} modulePath - NPM module name or file path to load.
+ *
+ * @returns {Promise<{isESM: boolean, module: *, filePath: string}>} An object with the loaded module & data including
+ *                                                                   file path and whether the module is ESM.
+ */
+export declare function loadWithData<T = any>(config: IConfig | IPlugin, modulePath: string): Promise<{
+    filePath: string;
+    isESM: boolean;
+    module: T;
+}>;
+/**
+ * Loads a module and returns an object with the module and data about the module.
+ *
+ * Uses cached `isESM` and `relativePath` in plugin manifest to determine if dynamic import (isESM = true)
+ * or require (isESM = false | undefined) should be used.
+ *
+ * A unique error, ModuleLoadError, combines both CJS and ESM loader module not found errors into a single error that
+ * provides a consistent stack trace and info.
+ *
+ * @param {Command.Cached} cached - Cached command data from plugin manifest.
+ * @param {string} modulePath - NPM module name or file path to load.
+ *
+ * @returns {Promise<{isESM: boolean, module: *, filePath: string}>} An object with the loaded module & data including
+ *                                                                   file path and whether the module is ESM.
+ */
+export declare function loadWithDataFromManifest<T = any>(cached: Command.Cached, modulePath: string): Promise<{
+    filePath: string;
+    isESM: boolean;
+    module: T;
+}>;
+/**
+ * For `.js` files uses `getPackageType` to determine if `type` is set to `module` in associated `package.json`. If
+ * the `modulePath` provided ends in `.mjs` it is assumed to be ESM.
+ *
+ * @param {string} filePath - File path to test.
+ *
+ * @returns {boolean} The modulePath is an ES Module.
+ * @see https://www.npmjs.com/package/get-package-type
+ */
+export declare function isPathModule(filePath: string): boolean;

node_modules/@oclif/core/lib/module-loader.js

@@ -0,0 +1,206 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.load = load;
+exports.loadWithData = loadWithData;
+exports.loadWithDataFromManifest = loadWithDataFromManifest;
+exports.isPathModule = isPathModule;
+const getPackageType = require('get-package-type');
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const node_url_1 = require("node:url");
+const ts_path_1 = require("./config/ts-path");
+const module_load_1 = require("./errors/errors/module-load");
+const fs_1 = require("./util/fs");
+/**
+ * Defines file extension resolution when source files do not have an extension.
+ */
+const SUPPORTED_EXTENSIONS = ['.ts', '.js', '.mjs', '.cjs', '.mts', '.cts', '.tsx', '.jsx'];
+const isPlugin = (config) => config.type !== undefined;
+function handleError(error, isESM, path) {
+    if (error.code === 'MODULE_NOT_FOUND' || error.code === 'ERR_MODULE_NOT_FOUND') {
+        throw new module_load_1.ModuleLoadError(`${isESM ? 'import()' : 'require'} failed to load ${path}: ${error.message}`);
+    }
+    throw error;
+}
+/**
+ * Loads and returns a module.
+ *
+ * Uses `getPackageType` to determine if `type` is set to 'module. If so loads '.js' files as ESM otherwise uses
+ * a bare require to load as CJS. Also loads '.mjs' files as ESM.
+ *
+ * Uses dynamic import to load ESM source or require for CommonJS.
+ *
+ * A unique error, ModuleLoadError, combines both CJS and ESM loader module not found errors into a single error that
+ * provides a consistent stack trace and info.
+ *
+ * @param {IConfig|IPlugin} config - Oclif config or plugin config.
+ * @param {string} modulePath - NPM module name or file path to load.
+ *
+ * @returns {Promise<*>} The entire ESM module from dynamic import or CJS module by require.
+ */
+async function load(config, modulePath) {
+    let filePath;
+    let isESM;
+    try {
+        ;
+        ({ filePath, isESM } = await resolvePath(config, modulePath));
+        return (isESM ? await import((0, node_url_1.pathToFileURL)(filePath).href) : require(filePath));
+    }
+    catch (error) {
+        handleError(error, isESM, filePath ?? modulePath);
+    }
+}
+/**
+ * Loads a module and returns an object with the module and data about the module.
+ *
+ * Uses `getPackageType` to determine if `type` is set to `module`. If so loads '.js' files as ESM otherwise uses
+ * a bare require to load as CJS. Also loads '.mjs' files as ESM.
+ *
+ * Uses dynamic import to load ESM source or require for CommonJS.
+ *
+ * A unique error, ModuleLoadError, combines both CJS and ESM loader module not found errors into a single error that
+ * provides a consistent stack trace and info.
+ *
+ * @param {IConfig|IPlugin} config - Oclif config or plugin config.
+ * @param {string} modulePath - NPM module name or file path to load.
+ *
+ * @returns {Promise<{isESM: boolean, module: *, filePath: string}>} An object with the loaded module & data including
+ *                                                                   file path and whether the module is ESM.
+ */
+async function loadWithData(config, modulePath) {
+    let filePath;
+    let isESM;
+    try {
+        ;
+        ({ filePath, isESM } = await resolvePath(config, modulePath));
+        const module = isESM ? await import((0, node_url_1.pathToFileURL)(filePath).href) : require(filePath);
+        return { filePath, isESM, module };
+    }
+    catch (error) {
+        handleError(error, isESM, filePath ?? modulePath);
+    }
+}
+/**
+ * Loads a module and returns an object with the module and data about the module.
+ *
+ * Uses cached `isESM` and `relativePath` in plugin manifest to determine if dynamic import (isESM = true)
+ * or require (isESM = false | undefined) should be used.
+ *
+ * A unique error, ModuleLoadError, combines both CJS and ESM loader module not found errors into a single error that
+ * provides a consistent stack trace and info.
+ *
+ * @param {Command.Cached} cached - Cached command data from plugin manifest.
+ * @param {string} modulePath - NPM module name or file path to load.
+ *
+ * @returns {Promise<{isESM: boolean, module: *, filePath: string}>} An object with the loaded module & data including
+ *                                                                   file path and whether the module is ESM.
+ */
+async function loadWithDataFromManifest(cached, modulePath) {
+    const { id, isESM, relativePath } = cached;
+    if (!relativePath) {
+        throw new module_load_1.ModuleLoadError(`Cached command ${id} does not have a relative path`);
+    }
+    if (isESM === undefined) {
+        throw new module_load_1.ModuleLoadError(`Cached command ${id} does not have the isESM property set`);
+    }
+    const filePath = (0, node_path_1.join)(modulePath, relativePath.join(node_path_1.sep));
+    try {
+        const module = isESM ? await import((0, node_url_1.pathToFileURL)(filePath).href) : require(filePath);
+        return { filePath, isESM, module };
+    }
+    catch (error) {
+        handleError(error, isESM, filePath ?? modulePath);
+    }
+}
+/**
+ * For `.js` files uses `getPackageType` to determine if `type` is set to `module` in associated `package.json`. If
+ * the `modulePath` provided ends in `.mjs` it is assumed to be ESM.
+ *
+ * @param {string} filePath - File path to test.
+ *
+ * @returns {boolean} The modulePath is an ES Module.
+ * @see https://www.npmjs.com/package/get-package-type
+ */
+function isPathModule(filePath) {
+    const extension = (0, node_path_1.extname)(filePath).toLowerCase();
+    switch (extension) {
+        case '.js':
+        case '.jsx':
+        case '.ts':
+        case '.tsx': {
+            return getPackageType.sync(filePath) === 'module';
+        }
+        case '.mjs':
+        case '.mts': {
+            return true;
+        }
+        default: {
+            return false;
+        }
+    }
+}
+/**
+ * Resolves a modulePath first by `require.resolve` to allow Node to resolve an actual module. If this fails then
+ * the `modulePath` is resolved from the root of the provided config. `Config.tsPath` is used for initial resolution.
+ * If this file path does not exist then several extensions are tried from `s_EXTENSIONS` in order: '.js', '.mjs',
+ * '.cjs'. After a file path has been selected `isPathModule` is used to determine if the file is an ES Module.
+ *
+ * @param {IConfig|IPlugin} config - Oclif config or plugin config.
+ * @param {string} modulePath - File path to load.
+ *
+ * @returns {{isESM: boolean, filePath: string}} An object including file path and whether the module is ESM.
+ */
+async function resolvePath(config, modulePath) {
+    let isESM;
+    let filePath;
+    try {
+        filePath = require.resolve(modulePath);
+        isESM = isPathModule(filePath);
+    }
+    catch {
+        filePath =
+            (isPlugin(config) ? await (0, ts_path_1.tsPath)(config.root, modulePath, config) : await (0, ts_path_1.tsPath)(config.root, modulePath)) ??
+                modulePath;
+        let fileExists = false;
+        let isDirectory = false;
+        if ((0, fs_1.existsSync)(filePath)) {
+            fileExists = true;
+            try {
+                if ((0, node_fs_1.lstatSync)(filePath)?.isDirectory?.()) {
+                    fileExists = false;
+                    isDirectory = true;
+                }
+            }
+            catch { }
+        }
+        if (!fileExists) {
+            // Try all supported extensions.
+            let foundPath = findFile(filePath);
+            if (!foundPath && isDirectory) {
+                // Since filePath is a directory, try looking for index file.
+                foundPath = findFile((0, node_path_1.join)(filePath, 'index'));
+            }
+            if (foundPath) {
+                filePath = foundPath;
+            }
+        }
+        isESM = isPathModule(filePath);
+    }
+    return { filePath, isESM };
+}
+/**
+ * Try adding the different extensions from `s_EXTENSIONS` to find the file.
+ *
+ * @param {string} filePath - File path to load.
+ *
+ * @returns {string | null} Modified file path including extension or null if file is not found.
+ */
+function findFile(filePath) {
+    for (const extension of SUPPORTED_EXTENSIONS) {
+        const testPath = `${filePath}${extension}`;
+        if ((0, fs_1.existsSync)(testPath)) {
+            return testPath;
+        }
+    }
+    return null;
+}

node_modules/@oclif/core/lib/parser/errors.d.ts

@@ -0,0 +1,52 @@
+import { CLIError } from '../errors';
+import { Arg, ArgInput, CLIParseErrorOptions, OptionFlag } from '../interfaces/parser';
+export { CLIError } from '../errors';
+export type Validation = {
+    name: string;
+    reason?: string | undefined;
+    status: 'failed' | 'success';
+    validationFn: string;
+};
+export declare class CLIParseError extends CLIError {
+    parse: CLIParseErrorOptions['parse'];
+    showHelp: boolean;
+    constructor(options: CLIParseErrorOptions & {
+        message: string;
+    });
+}
+export declare class InvalidArgsSpecError extends CLIParseError {
+    args: ArgInput;
+    constructor({ args, exit, parse }: CLIParseErrorOptions & {
+        args: ArgInput;
+    });
+}
+export declare class RequiredArgsError extends CLIParseError {
+    args: Arg<any>[];
+    constructor({ args, exit, flagsWithMultiple, parse, }: CLIParseErrorOptions & {
+        args: Arg<any>[];
+        flagsWithMultiple?: string[];
+    });
+}
+export declare class UnexpectedArgsError extends CLIParseError {
+    args: unknown[];
+    constructor({ args, exit, parse }: CLIParseErrorOptions & {
+        args: unknown[];
+    });
+}
+export declare class NonExistentFlagsError extends CLIParseError {
+    flags: string[];
+    constructor({ exit, flags, parse }: CLIParseErrorOptions & {
+        flags: string[];
+    });
+}
+export declare class FlagInvalidOptionError extends CLIParseError {
+    constructor(flag: OptionFlag<any>, input: string);
+}
+export declare class ArgInvalidOptionError extends CLIParseError {
+    constructor(arg: Arg<any>, input: string);
+}
+export declare class FailedFlagValidationError extends CLIParseError {
+    constructor({ exit, failed, parse }: CLIParseErrorOptions & {
+        failed: Validation[];
+    });
+}

node_modules/@oclif/core/lib/parser/errors.js

@@ -0,0 +1,104 @@
+"use strict";
+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.RequiredArgsError = exports.InvalidArgsSpecError = exports.CLIParseError = exports.CLIError = void 0;
+const cache_1 = __importDefault(require("../cache"));
+const errors_1 = require("../errors");
+const util_1 = require("../util/util");
+const list_1 = __importDefault(require("../ux/list"));
+const theme_1 = require("../ux/theme");
+var errors_2 = require("../errors");
+Object.defineProperty(exports, "CLIError", { enumerable: true, get: function () { return errors_2.CLIError; } });
+class CLIParseError extends errors_1.CLIError {
+    parse;
+    showHelp = false;
+    constructor(options) {
+        options.message += '\nSee more help with --help';
+        super(options.message, { exit: options.exit });
+        this.parse = options.parse;
+    }
+}
+exports.CLIParseError = CLIParseError;
+class InvalidArgsSpecError extends CLIParseError {
+    args;
+    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.default)(namedArgs.map((a) => [`${a.name} (${a.required ? 'required' : 'optional'})`, a.description]));
+            message += `:\n${list}`;
+        }
+        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, 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) {
+            const list = (0, list_1.default)(namedArgs.map((a) => {
+                const description = a.options ? `(${a.options.join('|')}) ${a.description}` : a.description;
+                return [a.name, description];
+            }));
+            message += `:\n${list}`;
+        }
+        if (flagsWithMultiple?.length) {
+            const flags = flagsWithMultiple.map((f) => `--${f}`).join(', ');
+            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({ exit: cache_1.default.getInstance().get('exitCodes')?.requiredArgs ?? exit, message, parse });
+        this.args = args;
+        this.showHelp = true;
+    }
+}
+exports.RequiredArgsError = RequiredArgsError;
+class UnexpectedArgsError extends CLIParseError {
+    args;
+    constructor({ args, exit, parse }) {
+        const message = `Unexpected argument${args.length === 1 ? '' : 's'}: ${args.join(', ')}`;
+        super({ exit: cache_1.default.getInstance().get('exitCodes')?.unexpectedArgs ?? exit, message, parse });
+        this.args = args;
+        this.showHelp = true;
+    }
+}
+exports.UnexpectedArgsError = UnexpectedArgsError;
+class NonExistentFlagsError extends CLIParseError {
+    flags;
+    constructor({ exit, flags, parse }) {
+        const message = `Nonexistent flag${flags.length === 1 ? '' : 's'}: ${flags.join(', ')}`;
+        super({ exit: cache_1.default.getInstance().get('exitCodes')?.nonExistentFlag ?? exit, message, parse });
+        this.flags = flags;
+        this.showHelp = true;
+    }
+}
+exports.NonExistentFlagsError = NonExistentFlagsError;
+class FlagInvalidOptionError extends CLIParseError {
+    constructor(flag, input) {
+        const message = `Expected --${flag.name}=${input} to be one of: ${flag.options.join(', ')}`;
+        super({ message, parse: {} });
+    }
+}
+exports.FlagInvalidOptionError = FlagInvalidOptionError;
+class ArgInvalidOptionError extends CLIParseError {
+    constructor(arg, input) {
+        const message = `Expected ${input} to be one of: ${arg.options.join(', ')}`;
+        super({ message, parse: {} });
+    }
+}
+exports.ArgInvalidOptionError = ArgInvalidOptionError;
+class FailedFlagValidationError extends CLIParseError {
+    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  ${(0, theme_1.colorize)('dim', deduped.join('\n  '))}`;
+        super({ exit: cache_1.default.getInstance().get('exitCodes')?.failedFlagValidation ?? exit, message, parse });
+    }
+}
+exports.FailedFlagValidationError = FailedFlagValidationError;