oclif 2.0.0 → 2.0.1

package/lib/commands/upload/win.js

@@ -1,23 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const command_1 = require("@oclif/command");
+const core_1 = require("@oclif/core");
 const qq = require("qqjs");
 const aws_1 = require("../../aws");
 const log_1 = require("../../log");
 const Tarballs = require("../../tarballs");
 const upload_util_1 = require("../../upload-util");
-class UploadWin extends command_1.Command {
+class UploadWin extends core_1.Command {
     async run() {
-        const { flags } = this.parse(UploadWin);
+        const { flags } = await this.parse(UploadWin);
         const buildConfig = await Tarballs.buildConfig(flags.root);
-        const { s3Config, version, config, dist, targets, gitSha } = buildConfig;
+        const { s3Config, config, dist } = buildConfig;
         const S3Options = {
             Bucket: s3Config.bucket,
             ACL: s3Config.acl || 'public-read',
         };
-        const archs = targets.filter(t => t.platform === 'win32').map(t => t.arch);
+        const archs = buildConfig.targets.filter(t => t.platform === 'win32').map(t => t.arch);
         for (const arch of archs) {
-            const templateKey = upload_util_1.templateShortKey('win32', { bin: config.bin, version: version, sha: gitSha, arch });
+            const templateKey = (0, upload_util_1.templateShortKey)('win32', { bin: config.bin, version: config.version, sha: buildConfig.gitSha, arch });
             const localKey = dist(`win32/${templateKey}`);
             // eslint-disable-next-line no-await-in-loop
             if (!await qq.exists(localKey))
@@ -25,9 +25,9 @@ class UploadWin extends command_1.Command {
                     suggestions: ['Run "oclif-dev pack:win" before uploading'],
                 });
         }
-        const cloudKeyBase = upload_util_1.commitAWSDir(config.pjson.version, gitSha, s3Config);
+        const cloudKeyBase = (0, upload_util_1.commitAWSDir)(config.pjson.version, buildConfig.gitSha, s3Config);
         const uploadWin = async (arch) => {
-            const templateKey = upload_util_1.templateShortKey('win32', { bin: config.bin, version: version, sha: gitSha, arch });
+            const templateKey = (0, upload_util_1.templateShortKey)('win32', { bin: config.bin, version: config.version, sha: buildConfig.gitSha, arch });
             const localExe = dist(`win32/${templateKey}`);
             const cloudKey = `${cloudKeyBase}/${templateKey}`;
             if (await qq.exists(localExe))
@@ -35,12 +35,11 @@ class UploadWin extends command_1.Command {
         };
         await uploadWin('x64');
         await uploadWin('x86');
-        log_1.log(`done uploading windows executables for v${version}-${gitSha}`);
+        (0, log_1.log)(`done uploading windows executables for v${config.version}-${buildConfig.gitSha}`);
     }
 }
 exports.default = UploadWin;
-UploadWin.hidden = true;
 UploadWin.description = 'upload windows installers built with pack:win';
 UploadWin.flags = {
-    root: command_1.flags.string({ char: 'r', description: 'path to oclif CLI root', default: '.', required: true }),
+    root: core_1.Flags.string({ char: 'r', description: 'path to oclif CLI root', default: '.', required: true }),
 };

package/lib/generators/{app.d.ts → cli.d.ts}

@@ -2,19 +2,12 @@ import * as Generator from 'yeoman-generator';
 declare class App extends Generator {
     options: {
         defaults?: boolean;
-        mocha: boolean;
-        circleci: boolean;
-        appveyor: boolean;
-        typescript: boolean;
-        eslint: boolean;
         yarn: boolean;
-        travisci: boolean;
     };
     args: {
         [k: string]: string;
     };
-    type: 'single' | 'multi' | 'plugin' | 'base';
-    path: string;
+    name: string;
     pjson: any;
     githubUser: string | undefined;
     answers: {
@@ -39,26 +32,13 @@ declare class App extends Generator {
             travisci: boolean;
         };
     };
-    mocha: boolean;
-    circleci: boolean;
-    appveyor: boolean;
-    ts: boolean;
-    eslint: boolean;
     yarn: boolean;
-    travisci: boolean;
-    get _ext(): "ts" | "js";
-    get _bin(): any;
     repository?: string;
-    constructor(args: any, opts: any);
+    constructor(args: string | string[], opts: Generator.GeneratorOptions);
     prompting(): Promise<void>;
     writing(): void;
     install(): Promise<void>;
     end(): void;
     private _gitignore;
-    private _eslintignore;
-    private _writeBase;
-    private _writePlugin;
-    private _writeSingle;
-    private _writeMulti;
 }
 export = App;

package/lib/generators/cli.js

@@ -0,0 +1,182 @@
+"use strict";
+const child_process_1 = require("child_process");
+const fs = require("fs");
+const _ = require("lodash");
+const path = require("path");
+const Generator = require("yeoman-generator");
+const yosay = require("yosay");
+const sortPjson = require('sort-pjson');
+const fixpack = require('@oclif/fixpack');
+const debug = require('debug')('generator-oclif');
+const { version } = require('../../package.json');
+const isWindows = process.platform === 'win32';
+let hasYarn = false;
+try {
+    (0, child_process_1.execSync)('yarn -v', { stdio: 'ignore' });
+    hasYarn = true;
+}
+catch (_a) { }
+class App extends Generator {
+    constructor(args, opts) {
+        super(args, opts);
+        this.name = opts.name;
+        this.options = {
+            defaults: opts.defaults,
+            yarn: hasYarn,
+        };
+    }
+    async prompting() {
+        const msg = 'Time to build an oclif CLI!';
+        this.log(yosay(`${msg} Version: ${version}`));
+        (0, child_process_1.execSync)(`git clone https://github.com/oclif/hello-world.git ${path.resolve(this.name)}`);
+        fs.rmdirSync(`${path.resolve(this.name, '.git')}`, { recursive: true });
+        this.destinationRoot(path.resolve(this.name));
+        process.chdir(this.destinationRoot());
+        this.githubUser = await this.user.github.username().catch(debug);
+        this.pjson = Object.assign({ scripts: {}, engines: {}, devDependencies: {}, dependencies: {}, oclif: {} }, this.fs.readJSON('package.json', {}));
+        let repository = this.destinationRoot().split(path.sep).slice(-2).join('/');
+        if (this.githubUser)
+            repository = `${this.githubUser}/${repository.split('/')[1]}`;
+        const defaults = Object.assign(Object.assign({ name: this.determineAppname().replace(/ /g, '-'), version: '0.0.0', license: 'MIT', author: this.githubUser ? `${this.user.git.name()} @${this.githubUser}` : this.user.git.name(), dependencies: {}, repository }, this.pjson), { engines: Object.assign({ node: '>=8.0.0' }, this.pjson.engines), options: this.options });
+        this.repository = defaults.repository;
+        if (this.repository && this.repository.url) {
+            this.repository = this.repository.url;
+        }
+        if (this.options.defaults) {
+            this.answers = defaults;
+        }
+        else {
+            this.answers = await this.prompt([
+                {
+                    type: 'input',
+                    name: 'name',
+                    message: 'npm package name',
+                    default: defaults.name,
+                },
+                {
+                    type: 'input',
+                    name: 'bin',
+                    message: 'command bin name the CLI will export',
+                    default: (answers) => answers.name,
+                },
+                {
+                    type: 'input',
+                    name: 'description',
+                    message: 'description',
+                    default: defaults.description,
+                },
+                {
+                    type: 'input',
+                    name: 'author',
+                    message: 'author',
+                    default: defaults.author,
+                },
+                {
+                    type: 'input',
+                    name: 'version',
+                    message: 'version',
+                    default: defaults.version,
+                    when: !this.pjson.version,
+                },
+                {
+                    type: 'input',
+                    name: 'license',
+                    message: 'license',
+                    default: defaults.license,
+                },
+                {
+                    type: 'input',
+                    name: 'github.user',
+                    message: 'Who is the GitHub owner of repository (https://github.com/OWNER/repo)',
+                    default: repository.split('/').slice(0, -1).pop(),
+                },
+                {
+                    type: 'input',
+                    name: 'github.repo',
+                    message: 'What is the GitHub name of repository (https://github.com/owner/REPO)',
+                    default: (answers) => (this.pjson.repository || answers.name || this.pjson.name).split('/').pop(),
+                },
+                {
+                    type: 'list',
+                    name: 'pkg',
+                    message: 'Select a package manager',
+                    choices: [
+                        { name: 'npm', value: 'npm' },
+                        { name: 'yarn', value: 'yarn' },
+                    ],
+                    default: () => this.options.yarn || hasYarn ? 1 : 0,
+                },
+            ]);
+        }
+        debug(this.answers);
+        if (!this.options.defaults) {
+            this.options = Object.assign(Object.assign({}, this.answers.ci), { yarn: this.answers.pkg === 'yarn' });
+        }
+        this.yarn = this.options.yarn;
+        this.pjson.name = this.answers.name || defaults.name;
+        this.pjson.description = this.answers.description || defaults.description;
+        this.pjson.version = this.answers.version || defaults.version;
+        this.pjson.engines.node = defaults.engines.node;
+        this.pjson.author = this.answers.author || defaults.author;
+        this.pjson.files = this.answers.files || defaults.files || '/lib';
+        this.pjson.license = this.answers.license || defaults.license;
+        // eslint-disable-next-line no-multi-assign
+        this.repository = this.pjson.repository = this.answers.github ? `${this.answers.github.user}/${this.answers.github.repo}` : defaults.repository;
+        this.pjson.homepage = `https://github.com/${this.repository}`;
+        this.pjson.bugs = `https://github.com/${this.repository}/issues`;
+        this.pjson.oclif.bin = this.answers.bin;
+        this.pjson.bin = {};
+        this.pjson.bin[this.pjson.oclif.bin] = './bin/run';
+    }
+    writing() {
+        if (this.pjson.oclif && Array.isArray(this.pjson.oclif.plugins)) {
+            this.pjson.oclif.plugins.sort();
+        }
+        if (this.fs.exists(this.destinationPath('./package.json'))) {
+            fixpack(this.destinationPath('./package.json'), require('@oclif/fixpack/config.json'));
+        }
+        if (_.isEmpty(this.pjson.oclif))
+            delete this.pjson.oclif;
+        this.pjson.files = _.uniq((this.pjson.files || []).sort());
+        this.fs.writeJSON(this.destinationPath('./package.json'), sortPjson(this.pjson));
+        this.fs.write(this.destinationPath('.gitignore'), this._gitignore());
+    }
+    async install() {
+        const dependencies = [];
+        const devDependencies = [];
+        if (isWindows)
+            devDependencies.push('rimraf');
+        const yarnOpts = {};
+        if (process.env.YARN_MUTEX)
+            yarnOpts.mutex = process.env.YARN_MUTEX;
+        const install = (deps, opts) => this.yarn ? this.yarnInstall(deps, opts) : this.npmInstall(deps, opts);
+        const dev = this.yarn ? { dev: true } : { 'save-dev': true };
+        const save = this.yarn ? {} : { save: true };
+        return Promise.all([
+            install(devDependencies, Object.assign(Object.assign(Object.assign({}, yarnOpts), dev), { ignoreScripts: true })),
+            install(dependencies, Object.assign(Object.assign({}, yarnOpts), save)),
+        ]).then(() => { });
+    }
+    end() {
+        this.spawnCommandSync(path.join('.', 'node_modules/.bin/oclif'), ['readme']);
+        console.log(`\nCreated ${this.pjson.name} in ${this.destinationRoot()}`);
+    }
+    _gitignore() {
+        const existing = this.fs.exists(this.destinationPath('.gitignore')) ? this.fs.read(this.destinationPath('.gitignore')).split('\n') : [];
+        return _([
+            '*-debug.log',
+            '*-error.log',
+            'node_modules',
+            '/tmp',
+            '/dist',
+            this.yarn ? '/package-lock.json' : '/yarn.lock',
+            '/lib',
+        ])
+            .concat(existing)
+            .compact()
+            .uniq()
+            .sort()
+            .join('\n') + '\n';
+    }
+}
+module.exports = App;

package/lib/help-compatibility.d.ts

@@ -1,12 +1,11 @@
-import { HelpBase } from '@oclif/plugin-help';
-import { Command } from '@oclif/config';
+import { Interfaces, HelpBase } from '@oclif/core';
 interface MaybeCompatibleHelp extends HelpBase {
-    formatCommand?: (command: Command) => string;
-    command?: (command: Command) => string;
+    formatCommand?: (command: Interfaces.Command) => string;
+    command?: (command: Interfaces.Command) => string;
 }
 export declare class HelpCompatibilityWrapper {
     inner: MaybeCompatibleHelp;
     constructor(inner: MaybeCompatibleHelp);
-    formatCommand(command: Command): string;
+    formatCommand(command: Interfaces.Command): string;
 }
 export {};

package/lib/help-compatibility.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.HelpCompatibilityWrapper = void 0;
 class IncompatibleHelpError extends Error {
     constructor() {
         super(...arguments);

package/lib/index.d.ts

@@ -1,2 +1,2 @@
-export { run } from '@oclif/command';
+export { run } from '@oclif/core';
 export { IManifest } from './tarballs';

package/lib/index.js

@@ -1,4 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-var command_1 = require("@oclif/command");
-exports.run = command_1.run;
+exports.run = void 0;
+var core_1 = require("@oclif/core");
+Object.defineProperty(exports, "run", { enumerable: true, get: function () { return core_1.run; } });

package/lib/log.js

@@ -1,12 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.log = exports.debug = void 0;
 const cli_ux_1 = require("cli-ux");
 const qq = require("qqjs");
 const util = require("util");
 exports.debug = require('debug')('oclif');
 exports.debug.new = (name) => require('debug')(`oclif:${name}`);
 function log(format, ...args) {
-    args = args.map(arg => qq.prettifyPaths(arg));
-    exports.debug.enabled ? exports.debug(format, ...args) : cli_ux_1.default.log(`oclif: ${util.format(format, ...args)}`);
+    args = args.map((arg) => qq.prettifyPaths(arg));
+    exports.debug.enabled ? (0, exports.debug)(format, ...args) : cli_ux_1.default.log(`oclif: ${util.format(format, ...args)}`);
 }
 exports.log = log;

package/lib/tarballs/bin.d.ts

@@ -1,6 +1,6 @@
-import * as Config from '@oclif/config';
+import { Interfaces } from '@oclif/core';
 export declare function writeBinScripts({ config, baseWorkspace, nodeVersion }: {
-    config: Config.IConfig;
+    config: Interfaces.Config;
     baseWorkspace: string;
     nodeVersion: string;
 }): Promise<void>;

package/lib/tarballs/bin.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeBinScripts = void 0;
 const qq = require("qqjs");
 async function writeBinScripts({ config, baseWorkspace, nodeVersion }) {
     const binPathEnvVar = config.scopedEnvVarKey('BINPATH');
@@ -7,7 +8,7 @@ async function writeBinScripts({ config, baseWorkspace, nodeVersion }) {
     const clientHomeEnvVar = config.scopedEnvVarKey('OCLIF_CLIENT_HOME');
     const writeWin32 = async () => {
         const { bin } = config;
-        await qq.write([baseWorkspace, 'bin', `${bin}.cmd`], `@echo off
+        await qq.write([baseWorkspace, 'bin', `${config.bin}.cmd`], `@echo off
 setlocal enableextensions
 
 if not "%${redirectedEnvVar}%"=="1" if exist "%LOCALAPPDATA%\\${bin}\\client\\bin\\${bin}.cmd" (

package/lib/tarballs/build.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.build = void 0;
 const findYarnWorkspaceRoot = require("find-yarn-workspace-root");
 const path = require("path");
 const qq = require("qqjs");
@@ -11,14 +12,14 @@ const pack = async (from, to) => {
     const prevCwd = qq.cwd();
     qq.cd(path.dirname(from));
     await qq.mkdirp(path.dirname(to));
-    log_1.log(`packing tarball from ${qq.prettifyPaths(from)} to ${qq.prettifyPaths(to)}`);
+    (0, log_1.log)(`packing tarball from ${qq.prettifyPaths(from)} to ${qq.prettifyPaths(to)}`);
     await (to.endsWith('gz') ?
         qq.x('tar', ['czf', to, path.basename(from)]) :
         qq.x(`tar c ${path.basename(from)} | xz > ${to}`));
     qq.cd(prevCwd);
 };
 async function build(c, options = {}) {
-    const { xz, config, version, s3Config, gitSha, nodeVersion, targets, updateConfig } = c;
+    const { xz, config } = c;
     const prevCwd = qq.cwd();
     const packCLI = async () => {
         const stdout = await qq.x.stdout('npm', ['pack', '--unsafe-perm'], { cwd: c.root });
@@ -39,10 +40,10 @@ async function build(c, options = {}) {
     const updatePJSON = async () => {
         qq.cd(c.workspace());
         const pjson = await qq.readJSON('package.json');
-        pjson.version = version;
+        pjson.version = config.version;
         pjson.oclif.update = pjson.oclif.update || {};
         pjson.oclif.update.s3 = pjson.oclif.update.s3 || {};
-        pjson.oclif.update.s3.bucket = s3Config.bucket;
+        pjson.oclif.update.s3.bucket = c.s3Config.bucket;
         await qq.writeJSON('package.json', pjson);
     };
     const addDependencies = async () => {
@@ -75,27 +76,27 @@ async function build(c, options = {}) {
     };
     const buildTarget = async (target) => {
         const workspace = c.workspace(target);
-        const gzLocalKey = upload_util_1.templateShortKey('versioned', '.tar.gz', {
+        const gzLocalKey = (0, upload_util_1.templateShortKey)('versioned', '.tar.gz', {
             arch: target.arch,
-            bin: config.bin,
+            bin: c.config.bin,
             platform: target.platform,
-            sha: gitSha,
+            sha: c.gitSha,
             version: config.version,
         });
-        const xzLocalKey = upload_util_1.templateShortKey('versioned', '.tar.xz', {
+        const xzLocalKey = (0, upload_util_1.templateShortKey)('versioned', '.tar.xz', {
             arch: target.arch,
-            bin: config.bin,
+            bin: c.config.bin,
             platform: target.platform,
-            sha: gitSha,
+            sha: c.gitSha,
             version: config.version,
         });
         const base = path.basename(gzLocalKey);
-        log_1.log(`building target ${base}`);
-        log_1.log('copying workspace', c.workspace(), workspace);
+        (0, log_1.log)(`building target ${base}`);
+        (0, log_1.log)('copying workspace', c.workspace(), workspace);
         await qq.rm(workspace);
         await qq.cp(c.workspace(), workspace);
-        await node_1.fetchNodeBinary({
-            nodeVersion: nodeVersion,
+        await (0, node_1.fetchNodeBinary)({
+            nodeVersion: c.nodeVersion,
             output: path.join(workspace, 'bin', 'node'),
             platform: target.platform,
             arch: target.arch,
@@ -106,41 +107,41 @@ async function build(c, options = {}) {
         await pack(workspace, c.dist(gzLocalKey));
         if (xz)
             await pack(workspace, c.dist(xzLocalKey));
-        if (!updateConfig.s3.host)
+        if (!c.updateConfig.s3.host)
             return;
-        const rollout = (typeof updateConfig.autoupdate === 'object' && updateConfig.autoupdate.rollout);
-        const gzCloudKey = `${upload_util_1.commitAWSDir(version, gitSha, updateConfig.s3)}/${gzLocalKey}`;
-        const xzCloudKey = `${upload_util_1.commitAWSDir(version, gitSha, updateConfig.s3)}/${xzLocalKey}`;
+        const rollout = (typeof c.updateConfig.autoupdate === 'object' && c.updateConfig.autoupdate.rollout);
+        const gzCloudKey = `${(0, upload_util_1.commitAWSDir)(config.version, c.gitSha, c.updateConfig.s3)}/${gzLocalKey}`;
+        const xzCloudKey = `${(0, upload_util_1.commitAWSDir)(config.version, c.gitSha, c.updateConfig.s3)}/${xzLocalKey}`;
         const manifest = {
             rollout: rollout === false ? undefined : rollout,
-            version: version,
-            sha: gitSha,
-            baseDir: upload_util_1.templateShortKey('baseDir', target, { bin: config.bin }),
+            version: config.version,
+            sha: c.gitSha,
+            baseDir: (0, upload_util_1.templateShortKey)('baseDir', target, { bin: c.config.bin }),
             gz: config.s3Url(gzCloudKey),
             xz: xz ? config.s3Url(xzCloudKey) : undefined,
             sha256gz: await qq.hash('sha256', c.dist(gzLocalKey)),
             sha256xz: xz ? await qq.hash('sha256', c.dist(xzLocalKey)) : undefined,
             node: {
                 compatible: config.pjson.engines.node,
-                recommended: nodeVersion,
+                recommended: c.nodeVersion,
             },
         };
-        const manifestFilepath = c.dist(upload_util_1.templateShortKey('manifest', {
+        const manifestFilepath = c.dist((0, upload_util_1.templateShortKey)('manifest', {
             arch: target.arch,
-            bin: config.bin,
+            bin: c.config.bin,
             platform: target.platform,
-            sha: gitSha,
+            sha: c.gitSha,
             version: config.version,
         }));
         await qq.writeJSON(manifestFilepath, manifest);
     };
-    log_1.log(`gathering workspace for ${config.bin} to ${c.workspace()}`);
+    (0, log_1.log)(`gathering workspace for ${config.bin} to ${c.workspace()}`);
     await extractCLI(await packCLI());
     await updatePJSON();
     await addDependencies();
-    await bin_1.writeBinScripts({ config, baseWorkspace: c.workspace(), nodeVersion: nodeVersion });
+    await (0, bin_1.writeBinScripts)({ config, baseWorkspace: c.workspace(), nodeVersion: c.nodeVersion });
     await pretarball();
-    for (const target of targets) {
+    for (const target of c.targets) {
         if (!options.platform || options.platform === target.platform) {
             // eslint-disable-next-line no-await-in-loop
             await buildTarget(target);

package/lib/tarballs/config.d.ts

@@ -1,11 +1,10 @@
-import * as Config from '@oclif/config';
+import { Interfaces } from '@oclif/core';
 export declare const TARGETS: string[];
 export interface BuildConfig {
     root: string;
     gitSha: string;
-    config: Config.IConfig;
+    config: Interfaces.Config;
     nodeVersion: string;
-    version: string;
     tmp: string;
     updateConfig: BuildConfig['config']['pjson']['oclif']['update'];
     s3Config: BuildConfig['updateConfig']['s3'] & {
@@ -14,12 +13,12 @@ export interface BuildConfig {
     };
     xz: boolean;
     targets: {
-        platform: Config.PlatformTypes;
-        arch: Config.ArchTypes;
+        platform: Interfaces.PlatformTypes;
+        arch: Interfaces.ArchTypes;
     }[];
     workspace(target?: {
-        platform: Config.PlatformTypes;
-        arch: Config.ArchTypes;
+        platform: Interfaces.PlatformTypes;
+        arch: Interfaces.ArchTypes;
     }): string;
     dist(input: string): string;
 }

package/lib/tarballs/config.js

@@ -1,18 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const Config = require("@oclif/config");
+exports.buildConfig = exports.gitSha = exports.TARGETS = void 0;
+const core_1 = require("@oclif/core");
 const path = require("path");
 const qq = require("qqjs");
+const semver = require("semver");
 const util_1 = require("../util");
 const upload_util_1 = require("../upload-util");
+const cli_ux_1 = require("cli-ux");
 exports.TARGETS = [
     'linux-x64',
     'linux-arm',
     'win32-x64',
     'win32-x86',
     'darwin-x64',
+    'darwin-arm64',
 ];
-function gitSha(cwd, options = {}) {
+async function gitSha(cwd, options = {}) {
     const args = options.short ? ['rev-parse', '--short', 'HEAD'] : ['rev-parse', 'HEAD'];
     return qq.x.stdout('git', args, { cwd });
 }
@@ -23,35 +27,43 @@ async function Tmp(config) {
     return tmp;
 }
 async function buildConfig(root, options = {}) {
-    const config = await Config.load({ root: path.resolve(root), devPlugins: false, userPlugins: false });
+    const config = await core_1.Config.load({ root: path.resolve(root), devPlugins: false, userPlugins: false });
     root = config.root;
     const _gitSha = await gitSha(root, { short: true });
-    const version = config.version.includes('-') ? `${config.version}.${_gitSha}` : config.version;
     // eslint-disable-next-line new-cap
     const tmp = await Tmp(config);
     const updateConfig = config.pjson.oclif.update || {};
     updateConfig.s3 = updateConfig.s3 || {};
+    const nodeVersion = updateConfig.node.version || process.versions.node;
+    const targets = (0, util_1.compact)(options.targets || updateConfig.node.targets || exports.TARGETS)
+        .filter(t => {
+        if (t === 'darwin-arm64' && semver.lt(nodeVersion, '16.0.0')) {
+            cli_ux_1.cli.warn('darwin-arm64 is only supported for node >=16.0.0. Skipping...');
+            return false;
+        }
+        return true;
+    })
+        .map(t => {
+        const [platform, arch] = t.split('-');
+        return { platform, arch };
+    });
     return {
         root,
         gitSha: _gitSha,
         config,
         tmp,
         updateConfig,
-        version,
         xz: typeof options.xz === 'boolean' ? options.xz : Boolean(updateConfig.s3.xz),
         dist: (...args) => path.join(config.root, 'dist', ...args),
         s3Config: updateConfig.s3,
-        nodeVersion: updateConfig.node.version || process.versions.node,
+        nodeVersion,
         workspace(target) {
             const base = qq.join(config.root, 'tmp');
             if (target && target.platform)
-                return qq.join(base, [target.platform, target.arch].join('-'), upload_util_1.templateShortKey('baseDir', { bin: config.bin }));
-            return qq.join(base, upload_util_1.templateShortKey('baseDir', { bin: config.bin }));
+                return qq.join(base, [target.platform, target.arch].join('-'), (0, upload_util_1.templateShortKey)('baseDir', { bin: config.bin }));
+            return qq.join(base, (0, upload_util_1.templateShortKey)('baseDir', { bin: config.bin }));
         },
-        targets: util_1.compact(options.targets || updateConfig.node.targets || exports.TARGETS).map(t => {
-            const [platform, arch] = t.split('-');
-            return { platform, arch };
-        }),
+        targets,
     };
 }
 exports.buildConfig = buildConfig;

package/lib/tarballs/index.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./bin"), exports);
-tslib_1.__exportStar(require("./build"), exports);
-tslib_1.__exportStar(require("./config"), exports);
-tslib_1.__exportStar(require("./node"), exports);
+(0, tslib_1.__exportStar)(require("./bin"), exports);
+(0, tslib_1.__exportStar)(require("./build"), exports);
+(0, tslib_1.__exportStar)(require("./config"), exports);
+(0, tslib_1.__exportStar)(require("./node"), exports);

package/lib/tarballs/node.d.ts

@@ -1,7 +1,10 @@
-export declare function fetchNodeBinary({ nodeVersion, output, platform, arch, tmp }: {
+import { Interfaces } from '@oclif/core';
+declare type Options = {
     nodeVersion: string;
     output: string;
-    platform: string;
-    arch: string;
+    platform: Interfaces.PlatformTypes;
+    arch: Interfaces.ArchTypes | 'armv7l';
     tmp: string;
-}): Promise<string>;
+};
+export declare function fetchNodeBinary({ nodeVersion, output, platform, arch, tmp }: Options): Promise<string>;
+export {};