@oclif/core 2.5.1 → 2.6.0

package/lib/config/config.d.ts

@@ -1,5 +1,5 @@
 import { Options, Plugin as IPlugin } from '../interfaces/plugin';
-import { Config as IConfig, ArchTypes, PlatformTypes, LoadOptions } from '../interfaces/config';
+import { Config as IConfig, ArchTypes, PlatformTypes, LoadOptions, VersionDetails } from '../interfaces/config';
 import { Hook, Hooks, PJSON, Topic } from '../interfaces';
 import * as Plugin from './plugin';
 import { Command } from '../command';
@@ -89,6 +89,7 @@ export declare class Config implements IConfig {
     get commands(): Command.Loadable[];
     get commandIDs(): string[];
     get topics(): Topic[];
+    get versionDetails(): VersionDetails;
     s3Key(type: keyof PJSON.S3.Templates, ext?: '.tar.gz' | '.tar.xz' | IConfig.s3Key.Options, options?: IConfig.s3Key.Options): string;
     s3Url(key: string): string;
     protected dir(category: 'cache' | 'data' | 'config'): string;

package/lib/config/config.js

@@ -416,6 +416,18 @@ class Config {
     get topics() {
         return [...this._topics.values()];
     }
+    get versionDetails() {
+        const [cliVersion, architecture, nodeVersion] = this.userAgent.split(' ');
+        return {
+            cliVersion,
+            architecture,
+            nodeVersion,
+            pluginVersions: Object.fromEntries(this.plugins.map(p => [p.name, { version: p.version, type: p.type, root: p.root }])),
+            osVersion: `${os.type()} ${os.release()}`,
+            shell: this.shell,
+            rootPath: this.root,
+        };
+    }
     s3Key(type, ext, options = {}) {
         if (typeof ext === 'object')
             options = ext;

package/lib/config/plugin.d.ts

@@ -24,6 +24,7 @@ export declare class Plugin implements IPlugin {
     parent: Plugin | undefined;
     children: Plugin[];
     hasManifest: boolean;
+    private _commandsDir;
     protected _debug: (..._: any) => void;
     protected warned: boolean;
     constructor(options: PluginOptions);

package/lib/config/plugin.js

@@ -141,7 +141,10 @@ class Plugin {
         return topicsToArray(this.pjson.oclif.topics || {});
     }
     get commandsDir() {
-        return (0, ts_node_1.tsPath)(this.root, this.pjson.oclif.commands);
+        if (this._commandsDir)
+            return this._commandsDir;
+        this._commandsDir = (0, ts_node_1.tsPath)(this.root, this.pjson.oclif.commands, this.type);
+        return this._commandsDir;
     }
     get commandIDs() {
         if (!this.commandsDir)
@@ -179,7 +182,7 @@ class Plugin {
             };
             let m;
             try {
-                const p = path.join(this.pjson.oclif.commands, ...id.split(':'));
+                const p = path.join(this.commandsDir ?? this.pjson.oclif.commands, ...id.split(':'));
                 const { isESM, module, filePath } = await module_loader_1.default.loadWithData(this, p);
                 this._debug(isESM ? '(import)' : '(require)', filePath);
                 m = module;

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

@@ -1,7 +1,7 @@
 /**
- * convert a path from the compiled ./lib files to the ./src typescript source
+ * Convert a path from the compiled ./lib files to the ./src typescript source
  * this is for developing typescript plugins/CLIs
- * if there is a tsconfig and the original sources exist, it attempts to require ts-
+ * if there is a tsconfig and the original sources exist, it attempts to require ts-node
  */
-export declare function tsPath(root: string, orig: string): string;
-export declare function tsPath(root: string, orig: string | undefined): string | undefined;
+export declare function tsPath(root: string, orig: string, type?: string): string;
+export declare function tsPath(root: string, orig: string | undefined, type?: string): string | undefined;

package/lib/config/ts-node.js

@@ -8,6 +8,8 @@ const util_1 = require("../util");
 const util_2 = require("./util");
 // eslint-disable-next-line new-cap
 const debug = (0, util_2.Debug)('ts-node');
+const TYPE_ROOTS = [`${__dirname}/../node_modules/@types`];
+const ROOT_DIRS = [];
 function loadTSConfig(root) {
     const tsconfigPath = path.join(root, 'tsconfig.json');
     let typescript;
@@ -29,19 +31,58 @@ function loadTSConfig(root) {
         return tsconfig;
     }
 }
-function tsPath(root, orig) {
+function registerTSNode(root) {
+    const tsconfig = loadTSConfig(root);
+    if (!tsconfig)
+        return;
+    debug('registering ts-node at', root);
+    const tsNodePath = require.resolve('ts-node', { paths: [root, __dirname] });
+    const tsNode = require(tsNodePath);
+    TYPE_ROOTS.push(`${root}/node_modules/@types`);
+    if (tsconfig.compilerOptions.rootDirs) {
+        ROOT_DIRS.push(...tsconfig.compilerOptions.rootDirs.map(r => path.join(root, r)));
+    }
+    else {
+        ROOT_DIRS.push(`${root}/src`);
+    }
+    const cwd = process.cwd();
+    try {
+        process.chdir(root);
+        tsNode.register({
+            skipProject: true,
+            transpileOnly: true,
+            compilerOptions: {
+                esModuleInterop: tsconfig.compilerOptions.esModuleInterop,
+                target: tsconfig.compilerOptions.target || 'es2017',
+                experimentalDecorators: tsconfig.compilerOptions.experimentalDecorators || false,
+                emitDecoratorMetadata: tsconfig.compilerOptions.emitDecoratorMetadata || false,
+                module: 'commonjs',
+                sourceMap: true,
+                rootDirs: ROOT_DIRS,
+                typeRoots: TYPE_ROOTS,
+                jsx: 'react',
+            },
+        });
+        return tsconfig;
+    }
+    finally {
+        process.chdir(cwd);
+    }
+}
+function tsPath(root, orig, type) {
     if (!orig)
         return orig;
-    orig = path.join(root, orig);
+    orig = orig.startsWith(root) ? orig : path.join(root, orig);
     const skipTSNode = 
     // the CLI specifically turned it off
     (settings_1.settings.tsnodeEnabled === false) ||
         // the CLI didn't specify ts-node and it is production
         (settings_1.settings.tsnodeEnabled === undefined && (0, util_1.isProd)());
-    if (skipTSNode)
+    // We always want to load the tsconfig for linked plugins.
+    if (skipTSNode && type !== 'link')
         return orig;
     try {
-        const tsconfig = loadTSConfig(root);
+        const tsconfig = type === 'link' ? registerTSNode(root) : loadTSConfig(root);
         if (!tsconfig)
             return orig;
         const { rootDir, rootDirs, outDir } = tsconfig.compilerOptions;

package/lib/interfaces/config.d.ts

@@ -6,6 +6,19 @@ import { Command } from '../command';
 export type LoadOptions = Options | string | Config | undefined;
 export type PlatformTypes = 'darwin' | 'linux' | 'win32' | 'aix' | 'freebsd' | 'openbsd' | 'sunos' | 'wsl';
 export type ArchTypes = 'arm' | 'arm64' | 'mips' | 'mipsel' | 'ppc' | 'ppc64' | 's390' | 's390x' | 'x32' | 'x64' | 'x86';
+export type VersionDetails = {
+    cliVersion: string;
+    architecture: string;
+    nodeVersion: string;
+    pluginVersions?: Record<string, {
+        version: string;
+        type: string;
+        root: string;
+    }>;
+    osVersion?: string;
+    shell?: string;
+    rootPath?: string;
+};
 export interface Config {
     name: string;
     version: string;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@oclif/core",
   "description": "base library for oclif CLIs",
-  "version": "2.5.1",
+  "version": "2.6.0",
   "author": "Salesforce",
   "bugs": "https://github.com/oclif/core/issues",
   "dependencies": {
@@ -29,6 +29,7 @@
     "strip-ansi": "^6.0.1",
     "supports-color": "^8.1.1",
     "supports-hyperlinks": "^2.2.0",
+    "ts-node": "^10.9.1",
     "tslib": "^2.5.0",
     "widest-line": "^3.1.0",
     "wordwrap": "^1.0.0",
@@ -73,7 +74,6 @@
     "shelljs": "^0.8.5",
     "shx": "^0.3.4",
     "sinon": "^11.1.2",
-    "ts-node": "^10.9.1",
     "tsd": "^0.25.0",
     "typescript": "^4.9.5"
   },