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

package/lib/interfaces/config.d.ts

@@ -21,91 +21,90 @@ export type VersionDetails = {
     rootPath?: string;
 };
 export interface Config {
-    name: string;
-    version: string;
-    channel: string;
-    pjson: PJSON.CLI;
-    root: string;
+    readonly name: string;
+    readonly version: string;
+    readonly channel: string;
+    readonly pjson: PJSON.CLI;
+    readonly root: string;
     /**
      * process.arch
      */
-    arch: ArchTypes;
+    readonly arch: ArchTypes;
     /**
      * bin name of CLI command
      */
-    bin: string;
+    readonly bin: string;
     /**
      * cache directory to use for CLI
      *
      * example ~/Library/Caches/mycli or ~/.cache/mycli
      */
-    cacheDir: string;
+    readonly cacheDir: string;
     /**
      * config directory to use for CLI
      *
      * example: ~/.config/mycli
      */
-    configDir: string;
+    readonly configDir: string;
     /**
      * data directory to use for CLI
      *
      * example: ~/.local/share/mycli
      */
-    dataDir: string;
+    readonly dataDir: string;
     /**
      * base dirname to use in cacheDir/configDir/dataDir
      */
-    dirname: string;
+    readonly dirname: string;
     /**
      * points to a file that should be appended to for error logs
      *
      * example: ~/Library/Caches/mycli/error.log
      */
-    errlog: string;
+    readonly errlog: string;
     /**
      * path to home directory
      *
      * example: /home/myuser
      */
-    home: string;
+    readonly home: string;
     /**
      * process.platform
      */
-    platform: PlatformTypes;
+    readonly platform: PlatformTypes;
     /**
      * active shell
      */
-    shell: string;
+    readonly shell: string;
     /**
      * user agent to use for http calls
      *
      * example: mycli/1.2.3 (darwin-x64) node-9.0.0
      */
-    userAgent: string;
+    readonly userAgent: string;
     /**
      * if windows
      */
-    windows: boolean;
+    readonly windows: boolean;
     /**
      * debugging level
      *
      * set by ${BIN}_DEBUG or DEBUG=$BIN
      */
-    debug: number;
+    readonly debug: number;
     /**
      * npm registry to use for installing plugins
      */
-    npmRegistry?: string;
-    userPJSON?: PJSON.User;
-    plugins: Plugin[];
-    binPath?: string;
+    readonly npmRegistry?: string;
+    readonly plugins: Map<string, Plugin>;
+    readonly binPath?: string;
     /**
      * name of any bin aliases that will execute the cli
      */
-    binAliases?: string[];
-    nsisCustomization?: string;
-    valid: boolean;
-    flexibleTaxonomy?: boolean;
+    readonly binAliases?: string[];
+    readonly nsisCustomization?: string;
+    readonly valid: boolean;
+    readonly flexibleTaxonomy?: boolean;
     topicSeparator: ':' | ' ';
     readonly commands: Command.Loadable[];
     readonly topics: Topic[];

package/lib/interfaces/parser.d.ts

@@ -62,88 +62,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>;
@@ -226,6 +164,11 @@ export type FlagProps = {
      * separate on spaces.
      */
     delimiter?: ',';
+    /**
+     * 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 ArgProps = {
     name: string;
@@ -245,6 +188,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';

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;
     };

package/lib/interfaces/plugin.d.ts

@@ -8,8 +8,10 @@ export interface PluginOptions {
     tag?: string;
     ignoreManifest?: boolean;
     errorOnManifestCreate?: boolean;
+    respectNoCacheDefault?: boolean;
     parent?: Plugin;
     children?: Plugin[];
+    flexibleTaxonomy?: boolean;
 }
 export interface Options extends PluginOptions {
     devPlugins?: boolean;
@@ -18,6 +20,7 @@ export interface Options extends PluginOptions {
     channel?: string;
     version?: string;
     enablePerf?: boolean;
+    plugins?: Map<string, Plugin>;
 }
 export interface Plugin {
     /**
@@ -78,5 +81,5 @@ export interface Plugin {
     findCommand(id: string, opts?: {
         must: boolean;
     }): Promise<Command.Class> | undefined;
-    load(isWritingManifest: boolean): Promise<void>;
+    load(): Promise<void>;
 }

package/lib/main.d.ts

@@ -2,52 +2,4 @@ import * as Interfaces from './interfaces';
 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>;
+export default function run(argv?: string[], options?: Interfaces.LoadOptions): Promise<unknown>;

package/lib/main.js

@@ -1,14 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.execute = exports.run = exports.versionAddition = exports.helpAddition = void 0;
+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");
 const help_1 = require("./help");
-const settings_1 = require("./settings");
-const _1 = require(".");
-const stream_1 = require("./cli-ux/stream");
+const stream_1 = require("./ux/stream");
 const performance_1 = require("./performance");
 const debug = require('debug')('oclif:main');
 const log = (message = '', ...args) => {
@@ -37,13 +35,13 @@ const versionAddition = (argv, config) => {
 };
 exports.versionAddition = versionAddition;
 async function run(argv, options) {
-    const marker = performance_1.Performance.mark('main.run');
-    const initMarker = performance_1.Performance.mark('main.run#init');
+    const marker = performance_1.default.mark('main.run');
+    const initMarker = performance_1.default.mark('main.run#init');
     const collectPerf = async () => {
         marker?.stop();
         initMarker?.stop();
-        await performance_1.Performance.collect();
-        performance_1.Performance.debug();
+        await performance_1.default.collect();
+        performance_1.default.debug();
     };
     debug(`process.execPath: ${process.execPath}`);
     debug(`process.execArgv: ${process.execArgv}`);
@@ -95,57 +93,4 @@ async function run(argv, options) {
         await collectPerf();
     }
 }
-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;
+exports.default = run;

package/lib/module-loader.d.ts

@@ -1,5 +1,4 @@
-import { Config as IConfig } from './interfaces';
-import { Plugin as IPlugin } from './interfaces';
+import { Config as IConfig, Plugin as IPlugin } from './interfaces';
 /**
  * Provides a static class with several utility methods to work with Oclif config / plugin to load ESM or CJS Node
  * modules and source files.

package/lib/module-loader.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const path = require("path");
 const url = require("url");
-const fs = require("fs-extra");
+const fs_1 = require("fs");
 const errors_1 = require("./errors");
 const config_1 = require("./config");
 const getPackageType = require('get-package-type');
@@ -131,10 +131,10 @@ class ModuleLoader {
             filePath = (isPlugin(config) ? (0, config_1.tsPath)(config.root, modulePath, config) : (0, config_1.tsPath)(config.root, modulePath)) ?? modulePath;
             let fileExists = false;
             let isDirectory = false;
-            if (fs.existsSync(filePath)) {
+            if ((0, fs_1.existsSync)(filePath)) {
                 fileExists = true;
                 try {
-                    if (fs.lstatSync(filePath)?.isDirectory?.()) {
+                    if ((0, fs_1.lstatSync)(filePath)?.isDirectory?.()) {
                         fileExists = false;
                         isDirectory = true;
                     }
@@ -167,7 +167,7 @@ class ModuleLoader {
         // eslint-disable-next-line camelcase
         for (const extension of s_EXTENSIONS) {
             const testPath = `${filePath}${extension}`;
-            if (fs.existsSync(testPath)) {
+            if ((0, fs_1.existsSync)(testPath)) {
                 return testPath;
             }
         }

package/lib/parser/errors.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.FailedFlagValidationError = exports.ArgInvalidOptionError = exports.FlagInvalidOptionError = exports.NonExistentFlagsError = exports.UnexpectedArgsError = exports.RequiredFlagError = exports.RequiredArgsError = exports.InvalidArgsSpecError = exports.CLIParseError = exports.CLIError = void 0;
 const errors_1 = require("../errors");
 const help_1 = require("./help");
-const list_1 = require("../cli-ux/list");
+const list_1 = require("../ux/list");
 const chalk = require("chalk");
 const util_1 = require("../config/util");
 var errors_2 = require("../errors");

package/lib/parser/parse.js

@@ -13,33 +13,7 @@ try {
 catch {
     debug = () => { };
 }
-/**
- * Support reading from stdin in Node 14 and older.
- *
- * This generally works for Node 14 and older EXCEPT when it's being
- * run from another process, in which case it will hang indefinitely. Because
- * of that issue we updated this to use AbortController but since AbortController
- * is only available in Node 16 and newer, we have to keep this legacy version.
- *
- * See these issues for more details on the hanging indefinitely bug:
- * https://github.com/oclif/core/issues/330
- * https://github.com/oclif/core/pull/363
- *
- * @returns Promise<string | null>
- */
-const readStdinLegacy = async () => {
-    const { stdin } = process;
-    let result;
-    if (stdin.isTTY)
-        return null;
-    result = '';
-    stdin.setEncoding('utf8');
-    for await (const chunk of stdin) {
-        result += chunk;
-    }
-    return result;
-};
-const readStdinWithTimeout = async () => {
+const readStdin = async () => {
     const { stdin, stdout } = process;
     // process.stdin.isTTY is true whenever it's running in a terminal.
     // process.stdin.isTTY is undefined when it's running in a pipe, e.g. echo 'foo' | my-cli command
@@ -74,13 +48,6 @@ const readStdinWithTimeout = async () => {
         }, { once: true });
     });
 };
-const readStdin = async () => {
-    const { stdin, version } = process;
-    debug('stdin.isTTY', stdin.isTTY);
-    const nodeMajorVersion = Number(version.split('.')[0].replace(/^v/, ''));
-    debug('node version', nodeMajorVersion);
-    return nodeMajorVersion > 14 ? readStdinWithTimeout() : readStdinLegacy();
-};
 function isNegativeNumber(input) {
     return /^-\d/g.test(input);
 }

package/lib/performance.d.ts

@@ -32,7 +32,7 @@ declare class Marker {
     stop(): void;
     measure(): void;
 }
-export declare class Performance {
+export default class Performance {
     private static markers;
     private static _results;
     private static _highlights;

package/lib/performance.js

@@ -1,6 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Performance = void 0;
 const perf_hooks_1 = require("perf_hooks");
 const settings_1 = require("./settings");
 class Marker {
@@ -30,7 +29,7 @@ class Marker {
 }
 class Performance {
     static get enabled() {
-        return settings_1.settings.performanceEnabled ?? false;
+        return settings_1.default.performanceEnabled ?? false;
     }
     static get results() {
         if (!Performance.enabled)
@@ -174,6 +173,6 @@ class Performance {
         }
     }
 }
-exports.Performance = Performance;
+exports.default = Performance;
 Performance.markers = {};
 Performance._results = [];

package/lib/screen.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.errtermwidth = exports.stdtermwidth = void 0;
-const stream_1 = require("./cli-ux/stream");
+const stream_1 = require("./ux/stream");
 const settings_1 = require("./settings");
 function termwidth(stream) {
     if (!stream.isTTY) {
@@ -16,6 +16,6 @@ function termwidth(stream) {
     }
     return width;
 }
-const columns = Number.parseInt(process.env.OCLIF_COLUMNS, 10) || settings_1.settings.columns;
+const columns = Number.parseInt(process.env.OCLIF_COLUMNS, 10) || settings_1.default.columns;
 exports.stdtermwidth = columns || termwidth(stream_1.stdout);
 exports.errtermwidth = columns || termwidth(stream_1.stderr);

package/lib/settings.d.ts

@@ -36,4 +36,5 @@ export type Settings = {
      */
     performanceEnabled?: boolean;
 };
-export declare const settings: Settings;
+declare const settings: Settings;
+export default settings;

package/lib/settings.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.settings = void 0;
 // Set global.oclif to the new object if it wasn't set before
 if (!global.oclif)
     global.oclif = {};
-exports.settings = global.oclif;
+const settings = global.oclif;
+exports.default = settings;

package/lib/{cli-ux → ux}/action/base.js

@@ -31,8 +31,8 @@ class ActionBase {
         this._stdout(false);
     }
     get globals() {
-        global['cli-ux'] = global['cli-ux'] || {};
-        const globals = global['cli-ux'];
+        global.ux = global.ux || {};
+        const globals = global.ux;
         globals.action = globals.action || {};
         return globals;
     }

package/lib/{cli-ux → ux}/action/spinner.js

@@ -4,7 +4,6 @@ const chalk = require("chalk");
 const supportsColor = require("supports-color");
 const stripAnsi = require('strip-ansi');
 const ansiStyles = require('ansi-styles');
-const ansiEscapes = require('ansi-escapes');
 const screen_1 = require("../../screen");
 const spinners_1 = require("./spinners");
 const base_1 = require("./base");
@@ -65,6 +64,7 @@ class SpinnerAction extends base_1.ActionBase {
     _reset() {
         if (!this.output)
             return;
+        const ansiEscapes = require('ansi-escapes');
         const lines = this._lines(this.output);
         this._write(this.std, ansiEscapes.cursorLeft + ansiEscapes.cursorUp(lines) + ansiEscapes.eraseDown);
         this.output = undefined;

package/lib/{cli-ux → ux}/config.d.ts

@@ -8,7 +8,6 @@ export interface ConfigMessage {
 export declare class Config {
     outputLevel: Levels;
     action: ActionBase;
-    prideAction: ActionBase;
     errorsHandled: boolean;
     showStackTrace: boolean;
     get debug(): boolean;

package/lib/{cli-ux → ux}/config.js

@@ -1,25 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.config = exports.Config = void 0;
-const semver = require("semver");
 const util_1 = require("../util");
 const spinner_1 = require("./action/spinner");
 const spinner_2 = require("./action/spinner");
-const pride_spinner_1 = require("./action/pride-spinner");
-const version = semver.parse((0, util_1.requireJson)(__dirname, '..', '..', 'package.json').version);
 const g = global;
-const globals = g['cli-ux'] || (g['cli-ux'] = {});
+const globals = g.ux || (g.ux = {});
 const actionType = (Boolean(process.stderr.isTTY) &&
     !process.env.CI &&
     !['dumb', 'emacs-color'].includes(process.env.TERM) &&
     'spinner') || 'simple';
 const Action = actionType === 'spinner' ? spinner_1.default : spinner_2.default;
-const PrideAction = actionType === 'spinner' ? pride_spinner_1.default : spinner_2.default;
 class Config {
     constructor() {
         this.outputLevel = 'info';
         this.action = new Action();
-        this.prideAction = new PrideAction();
         this.errorsHandled = false;
         this.showStackTrace = true;
     }
@@ -38,10 +33,11 @@ class Config {
 }
 exports.Config = Config;
 function fetch() {
-    if (globals[version.major])
-        return globals[version.major];
-    globals[version.major] = new Config();
-    return globals[version.major];
+    const major = (0, util_1.requireJson)(__dirname, '..', '..', 'package.json').version.split('.')[0];
+    if (globals[major])
+        return globals[major];
+    globals[major] = new Config();
+    return globals[major];
 }
 exports.config = fetch();
 exports.default = exports.config;