@oclif/core 3.9.2 → 3.10.0

package/lib/config/plugin.d.ts

@@ -8,7 +8,9 @@ export declare class Plugin implements IPlugin {
     alias: string;
     alreadyLoaded: boolean;
     children: Plugin[];
+    commandIDs: string[];
     commands: Command.Loadable[];
+    commandsDir: string | undefined;
     hasManifest: boolean;
     hooks: {
         [k: string]: string[];
@@ -26,12 +28,9 @@ export declare class Plugin implements IPlugin {
     version: string;
     protected warned: boolean;
     _base: string;
-    private _commandsDir;
     protected _debug: (..._: any) => void;
     private flexibleTaxonomy;
     constructor(options: PluginOptions);
-    get commandIDs(): string[];
-    get commandsDir(): string | undefined;
     get topics(): Topic[];
     findCommand(id: string, opts: {
         must: true;
@@ -42,5 +41,7 @@ export declare class Plugin implements IPlugin {
     load(): Promise<void>;
     private _manifest;
     private addErrorScope;
+    private getCommandIDs;
+    private getCommandsDir;
     private warn;
 }

package/lib/config/plugin.js

@@ -1,7 +1,10 @@
 "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 globby_1 = require("globby");
+const globby_1 = __importDefault(require("globby"));
 const node_path_1 = require("node:path");
 const node_util_1 = require("node:util");
 const errors_1 = require("../errors");
@@ -34,12 +37,27 @@ const search = (cmd) => {
         return cmd.default;
     return Object.values(cmd).find((cmd) => typeof cmd.run === 'function');
 };
+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 === '' ? '.' : id;
+    });
+}
 class Plugin {
     options;
     alias;
     alreadyLoaded = false;
     children = [];
+    commandIDs = [];
     commands;
+    commandsDir;
     hasManifest = false;
     hooks;
     isRoot = false;
@@ -55,40 +73,12 @@ class Plugin {
     version;
     warned = false;
     _base = `${_pjson.name}@${_pjson.version}`;
-    _commandsDir;
     // eslint-disable-next-line new-cap
     _debug = (0, util_2.Debug)();
     flexibleTaxonomy;
     constructor(options) {
         this.options = options;
     }
-    get commandIDs() {
-        if (!this.commandsDir)
-            return [];
-        const marker = performance_1.Performance.mark(performance_1.OCLIF_MARKER_OWNER, `plugin.commandIDs#${this.name}`, { plugin: this.name });
-        this._debug(`loading IDs from ${this.commandsDir}`);
-        const patterns = [
-            '**/*.+(js|cjs|mjs|ts|tsx|mts|cts)',
-            '!**/*.+(d.ts|test.ts|test.js|spec.ts|spec.js|d.mts|d.cts)?(x)',
-        ];
-        const ids = (0, globby_1.sync)(patterns, { cwd: this.commandsDir }).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 === '' ? '.' : id;
-        });
-        this._debug('found commands', ids);
-        marker?.addDetails({ count: ids.length });
-        marker?.stop();
-        return ids;
-    }
-    get commandsDir() {
-        if (this._commandsDir)
-            return this._commandsDir;
-        this._commandsDir = (0, ts_node_1.tsPath)(this.root, this.pjson.oclif.commands, this);
-        return this._commandsDir;
-    }
     get topics() {
         return topicsToArray(this.pjson.oclif.topics || {});
     }
@@ -131,7 +121,7 @@ class Plugin {
         return cmd;
     }
     async load() {
-        this.type = this.options.type || 'core';
+        this.type = this.options.type ?? 'core';
         this.tag = this.options.tag;
         this.isRoot = this.options.isRoot ?? false;
         if (this.options.parent)
@@ -143,7 +133,7 @@ class Plugin {
         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('reading %s plugin %s', this.type, root);
+        this._debug(`loading ${this.type} plugin from ${root}`);
         this.pjson = await (0, fs_1.readJson)((0, node_path_1.join)(root, 'package.json'));
         this.flexibleTaxonomy = this.options?.flexibleTaxonomy || this.pjson.oclif?.flexibleTaxonomy || false;
         this.moduleType = this.pjson.type === 'module' ? 'module' : 'commonjs';
@@ -163,7 +153,12 @@ class Plugin {
         else {
             this.pjson.oclif = this.pjson['cli-engine'] || {};
         }
-        this.hooks = (0, util_1.mapValues)(this.pjson.oclif.hooks ?? {}, (i) => (0, util_1.castArray)(i).map((i) => (0, ts_node_1.tsPath)(this.root, i, this)));
+        this.commandsDir = await this.getCommandsDir();
+        this.commandIDs = await this.getCommandIDs();
+        this.hooks = Object.fromEntries(await Promise.all(Object.entries(this.pjson.oclif.hooks ?? {}).map(async ([k, v]) => [
+            k,
+            await Promise.all((0, util_1.castArray)(v).map(async (i) => (0, ts_node_1.tsPath)(this.root, i, this))),
+        ])));
         this.manifest = await this._manifest();
         this.commands = Object.entries(this.manifest.commands)
             .map(([id, c]) => ({
@@ -253,6 +248,21 @@ class Plugin {
         ]).join('\n');
         return err;
     }
+    async getCommandIDs() {
+        if (!this.commandsDir)
+            return [];
+        const marker = performance_1.Performance.mark(performance_1.OCLIF_MARKER_OWNER, `plugin.getCommandIDs#${this.name}`, { plugin: this.name });
+        this._debug(`loading IDs from ${this.commandsDir}`);
+        const files = await (0, globby_1.default)(GLOB_PATTERNS, { cwd: this.commandsDir });
+        const ids = processCommandIds(files);
+        this._debug('found commands', ids);
+        marker?.addDetails({ count: ids.length });
+        marker?.stop();
+        return ids;
+    }
+    async getCommandsDir() {
+        return (0, ts_node_1.tsPath)(this.root, this.pjson.oclif.commands, this);
+    }
     warn(err, scope) {
         if (this.warned)
             return;

package/lib/config/ts-node.d.ts

@@ -5,5 +5,5 @@ export declare const TS_CONFIGS: Record<string, TSConfig>;
  * 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): string;
-export declare function tsPath(root: string, orig: string | undefined, plugin?: Plugin): string | undefined;
+export declare function tsPath(root: string, orig: string, plugin: Plugin): Promise<string>;
+export declare function tsPath(root: string, orig: string | undefined, plugin?: Plugin): Promise<string | undefined>;

package/lib/config/ts-node.js

@@ -15,36 +15,32 @@ const util_2 = require("./util");
 const debug = (0, util_2.Debug)('ts-node');
 exports.TS_CONFIGS = {};
 const REGISTERED = new Set();
-function loadTSConfig(root) {
-    if (exports.TS_CONFIGS[root])
-        return exports.TS_CONFIGS[root];
-    const tsconfigPath = (0, node_path_1.join)(root, 'tsconfig.json');
-    let typescript;
+async function loadTSConfig(root) {
     try {
-        typescript = require('typescript');
-    }
-    catch {
-        try {
-            typescript = require(require.resolve('typescript', { paths: [root, __dirname] }));
-        }
-        catch {
-            debug(`Could not find typescript dependency. Skipping ts-node registration for ${root}.`);
-            (0, errors_1.memoizedWarn)('Could not find typescript. Please ensure that typescript is a devDependency. Falling back to compiled source.');
+        if (exports.TS_CONFIGS[root])
+            return exports.TS_CONFIGS[root];
+        const tsconfigPath = (0, node_path_1.join)(root, 'tsconfig.json');
+        const tsconfig = await (0, fs_1.readJson)(tsconfigPath);
+        if (!tsconfig || Object.keys(tsconfig.compilerOptions).length === 0)
             return;
+        exports.TS_CONFIGS[root] = tsconfig;
+        if (tsconfig.extends) {
+            const { parse } = await import('tsconfck');
+            const result = await parse(tsconfigPath);
+            const tsNodeOpts = Object.fromEntries((result.extended ?? []).flatMap((e) => Object.entries(e.tsconfig['ts-node'] ?? {})).reverse());
+            exports.TS_CONFIGS[root] = { ...result.tsconfig, 'ts-node': tsNodeOpts };
         }
+        return exports.TS_CONFIGS[root];
     }
-    if ((0, fs_1.existsSync)(tsconfigPath) && typescript) {
-        const tsconfig = typescript.parseConfigFileTextToJson(tsconfigPath, (0, fs_1.readJsonSync)(tsconfigPath, false)).config;
-        if (!tsconfig || !tsconfig.compilerOptions) {
-            throw new Error(`Could not read and parse tsconfig.json at ${tsconfigPath}, or it ` +
-                'did not contain a "compilerOptions" section.');
+    catch (error) {
+        if (error instanceof SyntaxError) {
+            debug(`Could not parse tsconfig.json. Skipping ts-node registration for ${root}.`);
+            (0, errors_1.memoizedWarn)(`Could not parse tsconfig.json for ${root}. Falling back to compiled source.`);
         }
-        exports.TS_CONFIGS[root] = tsconfig;
-        return tsconfig;
     }
 }
-function registerTSNode(root) {
-    const tsconfig = loadTSConfig(root);
+async function registerTSNode(root) {
+    const tsconfig = await loadTSConfig(root);
     if (!tsconfig)
         return;
     if (REGISTERED.has(root))
@@ -71,24 +67,24 @@ function registerTSNode(root) {
     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: {
-            emitDecoratorMetadata: tsconfig.compilerOptions.emitDecoratorMetadata ?? false,
-            esModuleInterop: tsconfig.compilerOptions.esModuleInterop,
-            experimentalDecorators: tsconfig.compilerOptions.experimentalDecorators ?? false,
-            module: tsconfig.compilerOptions.module ?? 'commonjs',
+            ...rest,
             rootDirs,
-            sourceMap: tsconfig.compilerOptions.sourceMap ?? true,
-            target: tsconfig.compilerOptions.target ?? 'es2019',
             typeRoots,
-            ...(tsconfig.compilerOptions.moduleResolution
-                ? { moduleResolution: tsconfig.compilerOptions.moduleResolution }
-                : {}),
-            ...(tsconfig.compilerOptions.jsx ? { jsx: tsconfig.compilerOptions.jsx } : {}),
         },
+        ...tsconfig['ts-node'],
         cwd: root,
         esm: tsconfig['ts-node']?.esm ?? true,
         experimentalSpecifierResolution: tsconfig['ts-node']?.experimentalSpecifierResolution ?? 'explicit',
@@ -99,7 +95,8 @@ function registerTSNode(root) {
     };
     tsNode.register(conf);
     REGISTERED.add(root);
-    debug('%O', tsconfig);
+    debug('tsconfig: %O', tsconfig);
+    debug('ts-node options: %O', conf);
     return tsconfig;
 }
 /**
@@ -136,8 +133,8 @@ function cannotUseTsNode(root, plugin, isProduction) {
 /**
  * Determine the path to the source file from the compiled ./lib files
  */
-function determinePath(root, orig) {
-    const tsconfig = registerTSNode(root);
+async function determinePath(root, orig) {
+    const tsconfig = await registerTSNode(root);
     if (!tsconfig)
         return orig;
     debug(`determining path for ${orig}`);
@@ -174,7 +171,7 @@ function determinePath(root, orig) {
         (0, errors_1.memoizedWarn)(`Could not find source for ${orig} based on tsconfig. Defaulting to compiled source.`);
     return orig;
 }
-function tsPath(root, orig, plugin) {
+async function tsPath(root, orig, plugin) {
     const rootPlugin = plugin?.options.isRoot ? plugin : cache_1.default.getInstance().get('rootPlugin');
     if (!orig)
         return orig;
@@ -204,7 +201,7 @@ function tsPath(root, orig, plugin) {
         return orig;
     }
     try {
-        return determinePath(root, orig);
+        return await determinePath(root, orig);
     }
     catch (error) {
         debug(error);

package/lib/errors/index.js

@@ -22,8 +22,12 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __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.Logger = exports.memoizedWarn = exports.warn = exports.error = exports.exit = exports.handle = exports.ModuleLoadError = exports.ExitError = exports.CLIError = exports.config = void 0;
+const write_1 = __importDefault(require("../cli-ux/write"));
 const config_1 = require("./config");
 const cli_1 = require("./errors/cli");
 const exit_1 = require("./errors/exit");
@@ -56,7 +60,8 @@ function error(input, options = {}) {
     err = (0, pretty_print_1.applyPrettyPrintOptions)(err, options);
     if (options.exit === false) {
         const message = (0, pretty_print_1.default)(err);
-        console.error(message);
+        if (message)
+            write_1.default.stderr(message + '\n');
         if (config_1.config.errorLogger)
             config_1.config.errorLogger.log(err?.stack ?? '');
     }
@@ -76,7 +81,8 @@ function warn(input) {
         throw new TypeError('first argument must be a string or instance of Error');
     }
     const message = (0, pretty_print_1.default)(err);
-    console.error(message);
+    if (message)
+        write_1.default.stderr(message + '\n');
     if (config_1.config.errorLogger)
         config_1.config.errorLogger.log(err?.stack ?? '');
 }

package/lib/interfaces/plugin.d.ts

@@ -35,6 +35,7 @@ export interface Plugin {
     alias: string;
     readonly commandIDs: string[];
     commands: Command.Loadable[];
+    readonly commandsDir: string | undefined;
     findCommand(id: string, opts: {
         must: true;
     }): Promise<Command.Class>;

package/lib/interfaces/ts-config.d.ts

@@ -13,9 +13,11 @@ export interface TSConfig {
         sourceMap?: boolean;
         target?: string;
     };
+    extends?: string;
     'ts-node'?: {
         esm?: boolean;
         experimentalSpecifierResolution?: 'explicit' | 'node';
         scope?: boolean;
+        swc?: boolean;
     };
 }

package/lib/module-loader.js

@@ -35,7 +35,7 @@ async function load(config, modulePath) {
     let isESM;
     try {
         ;
-        ({ filePath, isESM } = resolvePath(config, modulePath));
+        ({ filePath, isESM } = await resolvePath(config, modulePath));
         return (isESM ? await import((0, node_url_1.pathToFileURL)(filePath).href) : require(filePath));
     }
     catch (error) {
@@ -68,7 +68,7 @@ async function loadWithData(config, modulePath) {
     let isESM;
     try {
         ;
-        ({ filePath, isESM } = resolvePath(config, modulePath));
+        ({ filePath, isESM } = await resolvePath(config, modulePath));
         const module = isESM ? await import((0, node_url_1.pathToFileURL)(filePath).href) : require(filePath);
         return { filePath, isESM, module };
     }
@@ -155,7 +155,7 @@ exports.isPathModule = isPathModule;
  *
  * @returns {{isESM: boolean, filePath: string}} An object including file path and whether the module is ESM.
  */
-function resolvePath(config, modulePath) {
+async function resolvePath(config, modulePath) {
     let isESM;
     let filePath;
     try {
@@ -164,7 +164,8 @@ function resolvePath(config, modulePath) {
     }
     catch {
         filePath =
-            (isPlugin(config) ? (0, ts_node_1.tsPath)(config.root, modulePath, config) : (0, ts_node_1.tsPath)(config.root, modulePath)) ?? modulePath;
+            (isPlugin(config) ? await (0, ts_node_1.tsPath)(config.root, modulePath, config) : await (0, ts_node_1.tsPath)(config.root, modulePath)) ??
+                modulePath;
         let fileExists = false;
         let isDirectory = false;
         if ((0, fs_1.existsSync)(filePath)) {

package/lib/util/find-root.js

@@ -1,8 +1,13 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.findRoot = void 0;
+const debug_1 = __importDefault(require("debug"));
 const node_path_1 = require("node:path");
 const fs_1 = require("./fs");
+const debug = (0, debug_1.default)('find-root');
 // essentially just "cd .."
 function* up(from) {
     while ((0, node_path_1.dirname)(from) !== from) {
@@ -21,7 +26,9 @@ async function findPluginRoot(root, name) {
     // If we know the plugin name then we just need to traverse the file
     // system until we find the directory that matches the plugin name.
     if (name) {
+        debug.extend(name)(`Finding root starting at ${root}`);
         for (const next of up(root)) {
+            debug.extend(name)(`Checking ${next}`);
             if (next.endsWith((0, node_path_1.basename)(name)))
                 return next;
         }
@@ -36,6 +43,7 @@ async function findPluginRoot(root, name) {
         }
         try {
             const cur = (0, node_path_1.join)(next, 'package.json');
+            debug.extend('root-plugin')(`Checking ${cur}`);
             if (await (0, fs_1.safeReadJson)(cur))
                 return (0, node_path_1.dirname)(cur);
         }
@@ -49,6 +57,7 @@ async function findPluginRoot(root, name) {
  * See https://github.com/oclif/config/pull/289#issuecomment-983904051
  */
 async function findRootLegacy(name, root) {
+    debug.extend(name ?? 'root-plugin')('Finding root using legacy method');
     for (const next of up(root)) {
         let cur;
         if (name) {
@@ -94,6 +103,7 @@ function findPnpRoot(name, root) {
     maybeRequirePnpApi(root);
     if (!pnp)
         return;
+    debug.extend(name)('Finding root for using pnp method');
     const seen = new Set();
     const traverseDependencyTree = (locator, parentPkg) => {
         // Prevent infinite recursion when A depends on B which depends on A
@@ -145,15 +155,29 @@ function findPnpRoot(name, root) {
  */
 async function findRoot(name, root) {
     if (name) {
+        debug.extend(name)(`Finding root using ${root}`);
         let pkgPath;
         try {
             pkgPath = require.resolve(name, { paths: [root] });
+            debug.extend(name)(`Found starting point with require.resolve`);
         }
-        catch { }
-        if (pkgPath)
-            return findPluginRoot((0, node_path_1.dirname)(pkgPath), name);
-        return process.versions.pnp ? findPnpRoot(name, root) : findRootLegacy(name, root);
+        catch {
+            debug.extend(name)(`require.resolve could not find plugin starting point`);
+        }
+        if (pkgPath) {
+            const found = await findPluginRoot((0, node_path_1.dirname)(pkgPath), name);
+            if (found) {
+                debug.extend(name)(`Found root at ${found}`);
+                return found;
+            }
+        }
+        const found = process.versions.pnp ? findPnpRoot(name, root) : await findRootLegacy(name, root);
+        debug.extend(name)(found ? `Found root at ${found}` : 'No root found!');
+        return found;
     }
-    return findPluginRoot(root);
+    debug.extend('root-plugin')(`Finding root plugin using ${root}`);
+    const found = await findPluginRoot(root);
+    debug.extend('root-plugin')(found ? `Found root at ${found}` : 'No root found!');
+    return found;
 }
 exports.findRoot = findRoot;

package/lib/util/fs.js

@@ -4,7 +4,6 @@ exports.existsSync = exports.safeReadJson = exports.readJsonSync = exports.readJ
 const node_fs_1 = require("node:fs");
 const promises_1 = require("node:fs/promises");
 const node_path_1 = require("node:path");
-const debug = require('debug');
 function requireJson(...pathParts) {
     return JSON.parse((0, node_fs_1.readFileSync)((0, node_path_1.join)(...pathParts), 'utf8'));
 }
@@ -50,7 +49,6 @@ const fileExists = async (input) => {
 };
 exports.fileExists = fileExists;
 async function readJson(path) {
-    debug('config')('readJson %s', path);
     const contents = await (0, promises_1.readFile)(path, 'utf8');
     return JSON.parse(contents);
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@oclif/core",
   "description": "base library for oclif CLIs",
-  "version": "3.9.2",
+  "version": "3.10.0",
   "author": "Salesforce",
   "bugs": "https://github.com/oclif/core/issues",
   "dependencies": {
@@ -27,6 +27,7 @@
     "strip-ansi": "^6.0.1",
     "supports-color": "^8.1.1",
     "supports-hyperlinks": "^2.2.0",
+    "tsconfck": "^3.0.0",
     "widest-line": "^3.1.0",
     "wordwrap": "^1.0.0",
     "wrap-ansi": "^7.0.0"
@@ -43,6 +44,7 @@
     "@types/chai-as-promised": "^7.1.5",
     "@types/clean-stack": "^2.1.1",
     "@types/cli-progress": "^3.11.0",
+    "@types/debug": "^4.1.10",
     "@types/ejs": "^3.1.3",
     "@types/indent-string": "^4.0.1",
     "@types/js-yaml": "^3.12.7",