@oclif/core 3.0.0-beta.1 → 3.0.0-beta.11

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[];
@@ -135,6 +134,7 @@ export interface Config {
     s3Url(key: string): string;
     s3Key(type: 'versioned' | 'unversioned', ext: '.tar.gz' | '.tar.xz', options?: Config.s3Key.Options): string;
     s3Key(type: keyof PJSON.S3.Templates, options?: Config.s3Key.Options): string;
+    getPluginsList(): Plugin[];
 }
 export declare namespace Config {
     namespace s3Key {

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

@@ -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;
     };
@@ -12,6 +13,7 @@ export interface PJSON {
         bin?: string;
         dirname?: string;
         hooks?: Record<string, string | string[]>;
+        plugins?: string[];
     };
 }
 export declare namespace PJSON {

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 {
     /**
@@ -49,6 +52,10 @@ export interface Plugin {
      * examples: core, link, user, dev
      */
     type: string;
+    /**
+     * Plugin is written in ESM or CommonJS
+     */
+    moduleType: 'module' | 'commonjs';
     /**
      * base path of plugin
      */
@@ -74,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/interfaces/ts-config.d.ts

@@ -7,5 +7,14 @@ export interface TSConfig {
         esModuleInterop?: boolean;
         experimentalDecorators?: boolean;
         emitDecoratorMetadata?: boolean;
+        module?: string;
+        moduleResolution?: string;
+        sourceMap?: boolean;
+        jsx?: boolean;
+    };
+    'ts-node'?: {
+        esm?: boolean;
+        experimentalSpecifierResolution?: 'node' | 'explicit';
+        scope?: boolean;
     };
 }

package/lib/main.d.ts

@@ -2,57 +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 ts-node
- * // eslint-disable-next-line node/shebang
- * (async () => {
- *   const oclif = await import('@oclif/core')
- *   await oclif.execute({type: 'esm', development: true, dir: import.meta.url})
- * })()
- * ```
- *
- * @example For ESM run.js
- * ```
- * #!/usr/bin/env node
- * // eslint-disable-next-line node/shebang
- * (async () => {
- *   const oclif = await import('@oclif/core')
- *   await oclif.execute({type: 'esm', dir: import.meta.url})
- * })()
- * ```
- *
- * @example For CJS dev.js
- * ```
- * #!/usr/bin/env node
- * // eslint-disable-next-line node/shebang
- * (async () => {
- *   const oclif = await import('@oclif/core')
- *   await oclif.execute({type: 'cjs', development: true, dir: __dirname})
- * })()
- * ```
- *
- * @example For CJS run.js
- * ```
- * #!/usr/bin/env node
- * // eslint-disable-next-line node/shebang
- * (async () => {
- *   const oclif = await import('@oclif/core')
- *   await oclif.execute({type: 'cjs', dir: import.meta.url})
- * })()
- * ```
- */
-export declare function execute(options: {
-    type: 'cjs' | 'esm';
-    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,16 +1,14 @@
 "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 path_1 = require("path");
 const stream_1 = require("./cli-ux/stream");
 const performance_1 = require("./performance");
+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');
@@ -37,14 +35,17 @@ 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}`);
+    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)) {
@@ -92,67 +93,4 @@ async function run(argv, options) {
         await collectPerf();
     }
 }
-exports.run = run;
-function getTsConfigPath(dir, type) {
-    return type === 'cjs' ? (0, path_1.join)(dir, '..', 'tsconfig.json') : (0, path_1.join)((0, path_1.dirname)((0, url_1.fileURLToPath)(dir)), '..', 'tsconfig.json');
-}
-/**
- * Load and run oclif CLI
- *
- * @param options - options to load the CLI
- * @returns Promise<void>
- *
- * @example For ESM dev.js
- * ```
- * #!/usr/bin/env ts-node
- * // eslint-disable-next-line node/shebang
- * (async () => {
- *   const oclif = await import('@oclif/core')
- *   await oclif.execute({type: 'esm', development: true, dir: import.meta.url})
- * })()
- * ```
- *
- * @example For ESM run.js
- * ```
- * #!/usr/bin/env node
- * // eslint-disable-next-line node/shebang
- * (async () => {
- *   const oclif = await import('@oclif/core')
- *   await oclif.execute({type: 'esm', dir: import.meta.url})
- * })()
- * ```
- *
- * @example For CJS dev.js
- * ```
- * #!/usr/bin/env node
- * // eslint-disable-next-line node/shebang
- * (async () => {
- *   const oclif = await import('@oclif/core')
- *   await oclif.execute({type: 'cjs', development: true, dir: __dirname})
- * })()
- * ```
- *
- * @example For CJS run.js
- * ```
- * #!/usr/bin/env node
- * // eslint-disable-next-line node/shebang
- * (async () => {
- *   const oclif = await import('@oclif/core')
- *   await oclif.execute({type: 'cjs', dir: import.meta.url})
- * })()
- * ```
- */
-async function execute(options) {
-    if (options.development) {
-        // In dev mode -> use ts-node and dev plugins
-        process.env.NODE_ENV = 'development';
-        require('ts-node').register({
-            project: getTsConfigPath(options.dir, options.type),
-        });
-        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,15 +2,18 @@
 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 = require("./config");
+const config_1 = require("./config");
 const getPackageType = require('get-package-type');
 /**
  * Defines file extension resolution when source files do not have an extension.
  */
 // eslint-disable-next-line camelcase
 const s_EXTENSIONS = ['.ts', '.js', '.mjs', '.cjs'];
+const isPlugin = (config) => {
+    return config.type !== undefined;
+};
 /**
  * Provides a static class with several utility methods to work with Oclif config / plugin to load ESM or CJS Node
  * modules and source files.
@@ -120,21 +123,18 @@ class ModuleLoader {
     static resolvePath(config, modulePath) {
         let isESM;
         let filePath;
-        const isPlugin = (config) => {
-            return config.type !== undefined;
-        };
         try {
             filePath = require.resolve(modulePath);
             isESM = ModuleLoader.isPathModule(filePath);
         }
         catch {
-            filePath = isPlugin(config) ? Config.tsPath(config.root, modulePath, config.type) : Config.tsPath(config.root, modulePath);
+            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/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 {
@@ -174,6 +173,6 @@ class Performance {
         }
     }
 }
-exports.Performance = Performance;
+exports.default = Performance;
 Performance.markers = {};
 Performance._results = [];