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

package/lib/interfaces/errors.d.ts

@@ -3,7 +3,7 @@ export type CommandError = Error & {
 };
 export interface OclifError {
     oclif: {
-        exit?: number | false;
+        exit?: number;
     };
 }
 export interface PrettyPrintableError {

package/lib/interfaces/hooks.d.ts

@@ -43,14 +43,14 @@ export interface Hooks {
         };
         return: void;
     };
-    'command_not_found': {
+    command_not_found: {
         options: {
             id: string;
             argv?: string[];
         };
         return: unknown;
     };
-    'command_incomplete': {
+    command_incomplete: {
         options: {
             id: string;
             argv: string[];
@@ -58,7 +58,7 @@ export interface Hooks {
         };
         return: unknown;
     };
-    'jit_plugin_not_installed': {
+    jit_plugin_not_installed: {
         options: {
             id: string;
             argv: string[];

package/lib/interfaces/index.d.ts

@@ -1,14 +1,14 @@
-export { AlphabetLowercase, AlphabetUppercase } from './alphabet';
-export { Config, ArchTypes, PlatformTypes, LoadOptions, VersionDetails, PluginVersionDetail } from './config';
-export { OclifError, PrettyPrintableError, CommandError } from './errors';
-export { HelpOptions } from './help';
-export { Hook, Hooks } from './hooks';
-export { Manifest } from './manifest';
-export { S3Manifest } from './s3-manifest';
-export { BooleanFlag, Flag, OptionFlag, Deprecation } from './parser';
-export { PJSON } from './pjson';
-export { Plugin, PluginOptions, Options } from './plugin';
-export { Topic } from './topic';
-export { TSConfig } from './ts-config';
-export { InferredFlags } from './flags';
-export { InferredArgs } from './args';
+export type { AlphabetLowercase, AlphabetUppercase } from './alphabet';
+export type { Config, ArchTypes, PlatformTypes, LoadOptions, VersionDetails, PluginVersionDetail } from './config';
+export type { OclifError, PrettyPrintableError, CommandError } from './errors';
+export type { HelpOptions } from './help';
+export type { Hook, Hooks } from './hooks';
+export type { Manifest } from './manifest';
+export type { S3Manifest } from './s3-manifest';
+export type { Arg, BooleanFlag, CustomOptions, Deprecation, Flag, FlagDefinition, OptionFlag } from './parser';
+export type { PJSON } from './pjson';
+export type { Plugin, PluginOptions, Options } from './plugin';
+export type { Topic } from './topic';
+export type { TSConfig } from './ts-config';
+export type { InferredFlags } from './flags';
+export type { InferredArgs } from './args';

package/lib/interfaces/parser.d.ts

@@ -1,6 +1,5 @@
-import { Command } from '../command';
 import { AlphabetLowercase, AlphabetUppercase } from './alphabet';
-import { Config } from './config';
+import { Command } from '../command';
 export type FlagOutput = {
     [name: string]: any;
 };
@@ -62,88 +61,26 @@ export type DefaultContext<T> = {
 /**
  * Type to define a default value for a flag.
  * @param context The context of the flag.
- * @param isWritingManifest Informs the function that a manifest file is being written.
- * The manifest file is used to store the flag definitions, with a default value if present, for a command and is published to npm.
- * When a manifest file is being written, the default value may contain data that should not be included in the manifest.
- * The plugin developer can use isWritingManifest to determine if the default value should be omitted from the manifest.
- * in the function's implementation.
- * @example
- * static flags = {
- *   foo: flags.string({
- *     defaultHelp: async (context, isWritingManifest) => {
- *       if (isWritingManifest) {
- *         return undefined
- *       }
- *       return 'value that is used outside a manifest'
- *     },
- *    }),
- *  }
  */
-export type FlagDefault<T, P = CustomOptions> = T | ((context: DefaultContext<P & OptionFlag<T, P>>, isWritingManifest?: boolean) => Promise<T>);
+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.
- * @param isWritingManifest Informs the function that a manifest file is being written.
- * The manifest file is used to store the flag definitions, with a default value if present via defaultHelp, for a command and is published to npm.
- * When a manifest file is being written, the default value may contain data that should not be included in the manifest.
- * The plugin developer can use isWritingManifest to determine if the defaultHelp value should be omitted from the manifest.
- * in the function's implementation.
- * @example
- * static flags = {
- *   foo: flags.string({
- *     defaultHelp: async (context, isWritingManifest) => {
- *       if (isWritingManifest) {
- *         return undefined
- *       }
- *       return 'value that is used outside a manifest'
- *     },
- *    }),
- *  }
  */
-export type FlagDefaultHelp<T, P = CustomOptions> = T | ((context: DefaultContext<P & OptionFlag<T, P>>, isWritingManifest?: boolean) => Promise<string | undefined>);
+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.
- * @param isWritingManifest Informs the function that a manifest file is being written.
- * The manifest file is used to store the arg definitions, with a default value if present, for a command and is published to npm.
- * When a manifest file is being written, the default value may contain data that should not be included in the manifest.
- * The plugin developer can use isWritingManifest to determine if the default value should be omitted from the manifest.
- * in the function's implementation.
- * @example
- *   public static readonly args = {
- *     one: Args.string({
- *       default: async (context, isWritingManifest) => {
- *          if (isWritingManifest) {
- *             return undefined
- *          }
- *          return 'value that is used outside a manifest'
- *       }),
- *   };
  */
-export type ArgDefault<T, P = CustomOptions> = T | ((context: DefaultContext<Arg<T, P>>, isWritingManifest?: boolean) => Promise<T>);
+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.
- * @param isWritingManifest Informs the function that a manifest file is being written.
- * The manifest file is used to store the arg definitions, with a default value if present via defaultHelp, for a command and is published to npm.
- * When a manifest file is being written, the default value may contain data that should not be included in the manifest.
- * The plugin developer can use isWritingManifest to determine if the default value should be omitted from the manifest.
- * in the function's implementation.
- * @example
- *   public static readonly args = {
- *     one: Args.string({
- *       defaultHelp: async (context, isWritingManifest) => {
- *          if (isWritingManifest) {
- *             return undefined
- *          }
- *          return 'value that is used outside a manifest'
- *       }),
- *   };
  */
-export type ArgDefaultHelp<T, P = CustomOptions> = T | ((context: DefaultContext<Arg<T, P>>, isWritingManifest?: boolean) => Promise<string | undefined>);
+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>;
@@ -216,16 +153,19 @@ export type FlagProps = {
      * 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;
     /**
-     * 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.
+     * 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.
      */
-    delimiter?: ',';
+    noCacheDefault?: boolean;
 };
 export type ArgProps = {
     name: string;
@@ -245,6 +185,11 @@ export type ArgProps = {
     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';
@@ -253,13 +198,19 @@ export type BooleanFlagProps = FlagProps & {
 export type OptionFlagProps = FlagProps & {
     type: 'option';
     helpValue?: string;
-    options?: string[];
+    options?: readonly string[];
     multiple?: 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?: ',';
 };
 export type FlagParserContext = Command & {
     token: FlagToken;
 };
-export type FlagParser<T, I extends string | boolean, P = CustomOptions> = (input: I, context: FlagParserContext, opts: P & OptionFlag<T, P>) => Promise<T>;
+export type FlagParser<T, I extends string | boolean, P = CustomOptions> = (input: I, context: FlagParserContext, opts: P & OptionFlag<T, P>) => T extends Array<infer U> ? Promise<U | undefined> : Promise<T | undefined>;
 export type ArgParserContext = Command & {
     token: ArgToken;
 };
@@ -286,45 +237,185 @@ export type BooleanFlag<T> = FlagProps & BooleanFlagProps & {
     default?: FlagDefault<boolean>;
     parse: (input: boolean, context: FlagParserContext, opts: FlagProps & BooleanFlagProps) => Promise<T>;
 };
-export type OptionFlagDefaults<T, P = CustomOptions, M = false> = FlagProps & OptionFlagProps & {
-    parse: FlagParser<T, string, P>;
-    defaultHelp?: FlagDefaultHelp<T>;
-    input: string[];
-    default?: M extends true ? FlagDefault<T[] | undefined, P> : FlagDefault<T | undefined, P>;
-};
 export type OptionFlag<T, P = CustomOptions> = FlagProps & OptionFlagProps & {
-    parse: FlagParser<T, string, P>;
+    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;
-} | {
-    default?: FlagDefault<T[] | undefined, P>;
-    multiple: true;
-});
-export type FlagDefinition<T, P = CustomOptions> = {
+    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: FlagDefault<T[]>;
-    }) & Partial<OptionFlag<T, P>>): OptionFlag<T[]>;
-    (options: P & {
+        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;
-    } & Partial<OptionFlag<T>>): OptionFlag<T[] | undefined>;
-    (options: P & ({
+        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: FlagDefault<T>;
-    }) & Partial<OptionFlag<T>>): OptionFlag<T>;
-    (options?: P & Partial<OptionFlag<T>>): OptionFlag<T | undefined>;
+        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;
     context?: ParserContext;
@@ -341,33 +432,14 @@ export type ParserInput = {
 export type ParserContext = Command & {
     token?: FlagToken | ArgToken;
 };
-export type CompletionContext = {
-    args?: {
-        [name: string]: string;
-    };
-    flags?: {
-        [name: string]: string;
-    };
-    argv?: string[];
-    config: Config;
-};
-export type Completion = {
-    skipCache?: boolean;
-    cacheDuration?: number;
-    cacheKey?(ctx: CompletionContext): Promise<string>;
-    options(ctx: CompletionContext): Promise<string[]>;
-};
-export type CompletableOptionFlag<T> = OptionFlag<T> & {
-    completion?: Completion;
-};
-export type CompletableFlag<T> = BooleanFlag<T> | CompletableOptionFlag<T>;
 export type FlagInput<T extends FlagOutput = {
     [flag: string]: any;
 }> = {
-    [P in keyof T]: CompletableFlag<T[P]>;
+    [P in keyof T]: Flag<T[P]>;
 };
 export type ArgInput<T extends ArgOutput = {
     [arg: string]: any;
 }> = {
     [P in keyof T]: Arg<T[P]>;
 };
+export {};

package/lib/interfaces/pjson.d.ts

@@ -1,6 +1,7 @@
 import { HelpOptions } from './help';
 export interface PJSON {
     [k: string]: any;
+    version: string;
     dependencies?: {
         [name: string]: string;
     };
@@ -25,7 +26,7 @@ export declare namespace PJSON {
             topicSeparator?: ':' | ' ';
             flexibleTaxonomy?: boolean;
             hooks?: {
-                [name: string]: (string | string[]);
+                [name: string]: string | string[];
             };
             commands?: string;
             default?: string;

package/lib/interfaces/plugin.d.ts

@@ -8,8 +8,11 @@ export interface PluginOptions {
     tag?: string;
     ignoreManifest?: boolean;
     errorOnManifestCreate?: boolean;
+    respectNoCacheDefault?: boolean;
     parent?: Plugin;
     children?: Plugin[];
+    flexibleTaxonomy?: boolean;
+    isRoot?: boolean;
 }
 export interface Options extends PluginOptions {
     devPlugins?: boolean;
@@ -18,6 +21,7 @@ export interface Options extends PluginOptions {
     channel?: string;
     version?: string;
     enablePerf?: boolean;
+    plugins?: Map<string, Plugin>;
 }
 export interface Plugin {
     /**
@@ -66,17 +70,22 @@ export interface Plugin {
      * 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;
+    /**
+     * True if the plugin is the root plugin.
+     */
+    isRoot: boolean;
     commands: Command.Loadable[];
     hooks: {
         [k: string]: string[];
     };
     readonly commandIDs: string[];
     readonly topics: Topic[];
+    readonly hasManifest: boolean;
     findCommand(id: string, opts: {
         must: true;
     }): Promise<Command.Class>;
     findCommand(id: string, opts?: {
         must: boolean;
     }): Promise<Command.Class> | undefined;
-    load(isWritingManifest: boolean): Promise<void>;
+    load(): Promise<void>;
 }

package/lib/main.d.ts

@@ -3,51 +3,3 @@ import { Config } from './config';
 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>;
-/**
- * Load and run oclif CLI
- *
- * @param options - options to load the CLI
- * @returns Promise<void>
- *
- * @example For ESM dev.js
- * ```
- * #!/usr/bin/env node
- * (async () => {
- *   const oclif = await import('@oclif/core')
- *   await oclif.execute({development: true, dir: import.meta.url})
- * })()
- * ```
- *
- * @example For ESM run.js
- * ```
- * #!/usr/bin/env node
- * (async () => {
- *   const oclif = await import('@oclif/core')
- *   await oclif.execute({dir: import.meta.url})
- * })()
- * ```
- *
- * @example For CJS dev.js
- * ```
- * #!/usr/bin/env node
- * (async () => {
- *   const oclif = await import('@oclif/core')
- *   await oclif.execute({development: true, dir: __dirname})
- * })()
- * ```
- *
- * @example For CJS run.js
- * ```
- * #!/usr/bin/env node
- * (async () => {
- *   const oclif = await import('@oclif/core')
- *   await oclif.execute({dir: __dirname})
- * })()
- * ```
- */
-export declare function execute(options: {
-    dir: string;
-    args?: string[];
-    loadOptions?: Interfaces.LoadOptions;
-    development?: boolean;
-}): Promise<void>;

package/lib/main.js

@@ -1,19 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.execute = exports.run = exports.versionAddition = exports.helpAddition = void 0;
-const url_1 = require("url");
-const util_1 = require("util");
-const url_2 = require("url");
-const config_1 = require("./config");
+exports.run = exports.versionAddition = exports.helpAddition = void 0;
+const node_url_1 = require("node:url");
+const node_util_1 = require("node:util");
 const help_1 = require("./help");
-const settings_1 = require("./settings");
-const _1 = require(".");
-const stream_1 = require("./cli-ux/stream");
+const config_1 = require("./config");
 const performance_1 = require("./performance");
+const stream_1 = require("./cli-ux/stream");
 const debug = require('debug')('oclif:main');
 const log = (message = '', ...args) => {
-    message = typeof message === 'string' ? message : (0, util_1.inspect)(message);
-    stream_1.stdout.write((0, util_1.format)(message, ...args) + '\n');
+    message = typeof message === 'string' ? message : (0, node_util_1.inspect)(message);
+    stream_1.stdout.write((0, node_util_1.format)(message, ...args) + '\n');
 };
 const helpAddition = (argv, config) => {
     if (argv.length === 0 && !config.pjson.oclif.default)
@@ -41,7 +38,8 @@ async function run(argv, options) {
     const initMarker = performance_1.Performance.mark('main.run#init');
     const collectPerf = async () => {
         marker?.stop();
-        initMarker?.stop();
+        if (!initMarker?.stopped)
+            initMarker?.stop();
         await performance_1.Performance.collect();
         performance_1.Performance.debug();
     };
@@ -50,8 +48,8 @@ async function run(argv, options) {
     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 url_2.URL)) {
-        options = (0, url_1.fileURLToPath)(options);
+    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);
     let [id, ...argvSlice] = (0, help_1.normalizeArgv)(config, argv);
@@ -96,56 +94,3 @@ async function run(argv, options) {
     }
 }
 exports.run = run;
-/**
- * Load and run oclif CLI
- *
- * @param options - options to load the CLI
- * @returns Promise<void>
- *
- * @example For ESM dev.js
- * ```
- * #!/usr/bin/env node
- * (async () => {
- *   const oclif = await import('@oclif/core')
- *   await oclif.execute({development: true, dir: import.meta.url})
- * })()
- * ```
- *
- * @example For ESM run.js
- * ```
- * #!/usr/bin/env node
- * (async () => {
- *   const oclif = await import('@oclif/core')
- *   await oclif.execute({dir: import.meta.url})
- * })()
- * ```
- *
- * @example For CJS dev.js
- * ```
- * #!/usr/bin/env node
- * (async () => {
- *   const oclif = await import('@oclif/core')
- *   await oclif.execute({development: true, dir: __dirname})
- * })()
- * ```
- *
- * @example For CJS run.js
- * ```
- * #!/usr/bin/env node
- * (async () => {
- *   const oclif = await import('@oclif/core')
- *   await oclif.execute({dir: __dirname})
- * })()
- * ```
- */
-async function execute(options) {
-    if (options.development) {
-        // In dev mode -> use ts-node and dev plugins
-        process.env.NODE_ENV = 'development';
-        settings_1.settings.debug = true;
-    }
-    await run(options.args ?? process.argv.slice(2), options.loadOptions ?? options.dir)
-        .then(async () => (0, _1.flush)())
-        .catch(_1.Errors.handle);
-}
-exports.execute = execute;