@oclif/plugin-update 2.2.0 → 3.0.0

package/CHANGELOG.md

@@ -2,6 +2,40 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+## [3.0.0](https://github.com/oclif/plugin-update/compare/v2.2.0...v3.0.0) (2022-02-11)
+
+
+### ⚠ BREAKING CHANGES
+
+* rename --from-local to --local
+
+* chore: update examples
+
+* feat!: remove --local flag
+* remove --local flag
+
+* refactor: Updater
+
+* fix: handle non-existent version index
+
+* chore: code review
+
+* chore: update test
+
+* fix: skip preupdate hook if using --hard
+
+* fix: update root after hard update
+
+* fix: works with sf
+
+* fix: replace --hard with --force
+
+* chore: update examples
+
+* chore: bump to 3.0.0
+
+* BREAKING CHANGE: add new update features (#368) ([091c176](https://github.com/oclif/plugin-update/commit/091c176ef639a7a0c991ab1b726e832783670324)), closes [#368](https://github.com/oclif/plugin-update/issues/368)
+
 ## [2.2.0](https://github.com/oclif/plugin-update/compare/v2.1.5...v2.2.0) (2022-01-28)
 
 

package/README.md

@@ -24,14 +24,34 @@ update the oclif-example CLI
 
 ```
 USAGE
-  $ oclif-example update [CHANNEL] [--from-local]
+  $ oclif-example update [CHANNEL] [-a] [-v <value> | -i] [--force]
 
 FLAGS
-  --from-local  interactively choose an already installed version
+  -a, --available        Install a specific version.
+  -i, --interactive      Interactively select version to install. This is ignored if a channel is provided.
+  -v, --version=<value>  Install a specific version.
+  --force                Force a re-download of the requested version.
 
 DESCRIPTION
   update the oclif-example CLI
+
+EXAMPLES
+  Update to the stable channel:
+
+    $ oclif-example update stable
+
+  Update to a specific version:
+
+    $ oclif-example update --version 1.0.0
+
+  Interactively select version:
+
+    $ oclif-example update --interactive
+
+  See available versions:
+
+    $ oclif-example update --available
 ```
 
-_See code: [src/commands/update.ts](https://github.com/oclif/plugin-update/blob/v2.1.5/src/commands/update.ts)_
+_See code: [src/commands/update.ts](https://github.com/oclif/plugin-update/blob/v3.0.0/src/commands/update.ts)_
 <!-- commandsstop -->

package/lib/commands/update.d.ts

@@ -5,12 +5,17 @@ export default class UpdateCommand extends Command {
         name: string;
         optional: boolean;
     }[];
+    static examples: {
+        description: string;
+        command: string;
+    }[];
     static flags: {
         autoupdate: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
-        'from-local': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        available: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        version: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined>;
+        interactive: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        force: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
     };
-    private channel;
-    private readonly clientRoot;
-    private readonly clientBin;
     run(): Promise<void>;
+    private promptForVersion;
 }

package/lib/commands/update.js

@@ -1,27 +1,85 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
 const core_1 = require("@oclif/core");
-const path = require("path");
+const inquirer_1 = require("inquirer");
+const path = (0, tslib_1.__importStar)(require("path"));
+const semver_1 = require("semver");
 const update_1 = require("../update");
-async function getPinToVersion() {
-    return core_1.CliUx.ux.prompt('Enter a version to update to');
-}
 class UpdateCommand extends core_1.Command {
-    constructor() {
-        super(...arguments);
-        this.clientRoot = this.config.scopedEnvVar('OCLIF_CLIENT_HOME') || path.join(this.config.dataDir, 'client');
-        this.clientBin = path.join(this.clientRoot, 'bin', this.config.windows ? `${this.config.bin}.cmd` : this.config.bin);
-    }
     async run() {
         const { args, flags } = await this.parse(UpdateCommand);
-        const updateCli = new update_1.default({ channel: args.channel, autoUpdate: flags.autoupdate, fromLocal: flags['from-local'], config: this.config, exit: this.exit, getPinToVersion: getPinToVersion });
-        return updateCli.runUpdate();
+        const updater = new update_1.Updater(this.config);
+        if (flags.available) {
+            const index = await updater.fetchVersionIndex();
+            const allVersions = (0, semver_1.sort)(Object.keys(index)).reverse();
+            const localVersions = await updater.findLocalVersions();
+            const table = allVersions.map(version => {
+                const location = localVersions.find(l => path.basename(l).startsWith(version)) || index[version];
+                return { version, location };
+            });
+            core_1.CliUx.ux.table(table, { version: {}, location: {} });
+            return;
+        }
+        if (args.channel && flags.version) {
+            this.error('You cannot specifiy both a version and a channel.');
+        }
+        return updater.runUpdate({
+            channel: args.channel,
+            autoUpdate: flags.autoupdate,
+            force: flags.force,
+            version: flags.interactive ? await this.promptForVersion(updater) : flags.version,
+        });
+    }
+    async promptForVersion(updater) {
+        const choices = (0, semver_1.sort)(Object.keys(await updater.fetchVersionIndex())).reverse();
+        const { version } = await (0, inquirer_1.prompt)({
+            name: 'version',
+            message: 'Select a version to update to',
+            type: 'list',
+            choices: [...choices, new inquirer_1.Separator()],
+        });
+        return version;
     }
 }
 exports.default = UpdateCommand;
 UpdateCommand.description = 'update the <%= config.bin %> CLI';
 UpdateCommand.args = [{ name: 'channel', optional: true }];
+UpdateCommand.examples = [
+    {
+        description: 'Update to the stable channel:',
+        command: '<%= config.bin %> <%= command.id %> stable',
+    },
+    {
+        description: 'Update to a specific version:',
+        command: '<%= config.bin %> <%= command.id %> --version 1.0.0',
+    },
+    {
+        description: 'Interactively select version:',
+        command: '<%= config.bin %> <%= command.id %> --interactive',
+    },
+    {
+        description: 'See available versions:',
+        command: '<%= config.bin %> <%= command.id %> --available',
+    },
+];
 UpdateCommand.flags = {
     autoupdate: core_1.Flags.boolean({ hidden: true }),
-    'from-local': core_1.Flags.boolean({ description: 'interactively choose an already installed version' }),
+    available: core_1.Flags.boolean({
+        char: 'a',
+        description: 'Install a specific version.',
+    }),
+    version: core_1.Flags.string({
+        char: 'v',
+        description: 'Install a specific version.',
+        exclusive: ['interactive'],
+    }),
+    interactive: core_1.Flags.boolean({
+        char: 'i',
+        description: 'Interactively select version to install. This is ignored if a channel is provided.',
+        exclusive: ['version'],
+    }),
+    force: core_1.Flags.boolean({
+        description: 'Force a re-download of the requested version.',
+    }),
 };

package/lib/hooks/init.js

@@ -1,10 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.init = void 0;
+const tslib_1 = require("tslib");
 const core_1 = require("@oclif/core");
-const spawn = require("cross-spawn");
-const fs = require("fs-extra");
-const path = require("path");
+const cross_spawn_1 = (0, tslib_1.__importDefault)(require("cross-spawn"));
+const fs = (0, tslib_1.__importStar)(require("fs-extra"));
+const path = (0, tslib_1.__importStar)(require("path"));
 const util_1 = require("../util");
 // eslint-disable-next-line unicorn/prefer-module
 const debug = require('debug')('cli:updater');
@@ -55,7 +56,7 @@ const init = async function (opts) {
     debug(`spawning autoupdate on ${binPath}`);
     const fd = await fs.open(autoupdatelogfile, 'a');
     fs.write(fd, timestamp(`starting \`${binPath} update --autoupdate\` from ${process.argv.slice(1, 3).join(' ')}\n`));
-    spawn(binPath, ['update', '--autoupdate'], {
+    (0, cross_spawn_1.default)(binPath, ['update', '--autoupdate'], {
         detached: !this.config.windows,
         stdio: ['ignore', fd, fd],
         env: autoupdateEnv,

package/lib/tar.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.extract = void 0;
-const fs = require("fs-extra");
-const path = require("path");
+const tslib_1 = require("tslib");
+const fs = (0, tslib_1.__importStar)(require("fs-extra"));
+const path = (0, tslib_1.__importStar)(require("path"));
 const util_1 = require("./util");
 const debug = require('debug')('oclif-update');
 const ignore = (_, header) => {

package/lib/update.d.ts

@@ -1,36 +1,43 @@
 import { Config } from '@oclif/core';
-export interface UpdateCliOptions {
-    channel?: string;
-    autoUpdate: boolean;
-    fromLocal: boolean;
-    config: Config;
-    exit: any;
-    getPinToVersion: () => Promise<string>;
+export declare namespace Updater {
+    type Options = {
+        autoUpdate: boolean;
+        channel?: string | undefined;
+        version?: string | undefined;
+        force?: boolean;
+    };
+    type VersionIndex = Record<string, string>;
 }
-export default class UpdateCli {
-    private options;
-    private channel;
-    private currentVersion?;
-    private updatedVersion;
+export declare class Updater {
+    private config;
     private readonly clientRoot;
     private readonly clientBin;
-    constructor(options: UpdateCliOptions);
-    runUpdate(): Promise<void>;
+    constructor(config: Config);
+    runUpdate(options: Updater.Options): Promise<void>;
+    findLocalVersions(): Promise<string[]>;
+    fetchVersionIndex(): Promise<Updater.VersionIndex>;
+    private ensureClientDir;
+    private composeS3SubDir;
+    private s3ChannelManifestKey;
+    private s3VersionManifestKey;
+    private s3VersionIndexKey;
+    private fetchChannelManifest;
+    private fetchVersionManifest;
     private fetchManifest;
     private downloadAndExtract;
     private update;
     private updateToExistingVersion;
-    private skipUpdate;
+    private notUpdatable;
+    private alreadyOnVersion;
     private determineChannel;
     private determineCurrentVersion;
-    private s3ChannelManifestKey;
+    private findLocalVersion;
     private setChannel;
     private logChop;
     private mtime;
     private debounce;
     private tidy;
     private touch;
-    private reexec;
+    private refreshConfig;
     private createBin;
-    private ensureClientDir;
 }

package/lib/update.js

@@ -1,116 +1,189 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.Updater = void 0;
+const tslib_1 = require("tslib");
 /* eslint-disable unicorn/prefer-module */
-const color_1 = require("@oclif/color");
+const color_1 = (0, tslib_1.__importDefault)(require("@oclif/color"));
 const core_1 = require("@oclif/core");
-const spawn = require("cross-spawn");
-const fs = require("fs-extra");
-const _ = require("lodash");
-const path = require("path");
+const fs = (0, tslib_1.__importStar)(require("fs-extra"));
+const http_call_1 = (0, tslib_1.__importDefault)(require("http-call"));
+const path = (0, tslib_1.__importStar)(require("path"));
+const lodash_throttle_1 = (0, tslib_1.__importDefault)(require("lodash.throttle"));
+const filesize_1 = (0, tslib_1.__importDefault)(require("filesize"));
 const tar_1 = require("./tar");
 const util_1 = require("./util");
-class UpdateCli {
-    constructor(options) {
-        this.options = options;
-        this.clientRoot = this.options.config.scopedEnvVar('OCLIF_CLIENT_HOME') || path.join(this.options.config.dataDir, 'client');
-        this.clientBin = path.join(this.clientRoot, 'bin', this.options.config.windows ? `${this.options.config.bin}.cmd` : this.options.config.bin);
+const filesize = (n) => {
+    const [num, suffix] = (0, filesize_1.default)(n, { output: 'array' });
+    return Number.parseFloat(num).toFixed(1) + ` ${suffix}`;
+};
+class Updater {
+    constructor(config) {
+        this.config = config;
+        this.clientRoot = config.scopedEnvVar('OCLIF_CLIENT_HOME') || path.join(config.dataDir, 'client');
+        this.clientBin = path.join(this.clientRoot, 'bin', config.windows ? `${config.bin}.cmd` : config.bin);
     }
-    async runUpdate() {
-        if (this.options.autoUpdate)
+    async runUpdate(options) {
+        const { autoUpdate, version, force = false } = options;
+        if (autoUpdate)
             await this.debounce();
-        this.channel = this.options.channel || await this.determineChannel();
-        if (this.options.fromLocal) {
-            await this.ensureClientDir();
-            core_1.CliUx.ux.debug(`Looking for locally installed versions at ${this.clientRoot}`);
-            // Do not show known non-local version folder names, bin and current.
-            const versions = fs.readdirSync(this.clientRoot).filter(dirOrFile => dirOrFile !== 'bin' && dirOrFile !== 'current');
-            if (versions.length === 0)
-                throw new Error('No locally installed versions found.');
-            core_1.CliUx.ux.log(`Found versions: \n${versions.map(version => `     ${version}`).join('\n')}\n`);
-            const pinToVersion = await this.options.getPinToVersion();
-            if (!versions.includes(pinToVersion))
-                throw new Error(`Version ${pinToVersion} not found in the locally installed versions.`);
-            if (!await fs.pathExists(path.join(this.clientRoot, pinToVersion))) {
-                throw new Error(`Version ${pinToVersion} is not already installed at ${this.clientRoot}.`);
+        core_1.CliUx.ux.action.start(`${this.config.name}: Updating CLI`);
+        if (this.notUpdatable()) {
+            core_1.CliUx.ux.action.stop('not updatable');
+            return;
+        }
+        const channel = options.channel || await this.determineChannel();
+        const current = await this.determineCurrentVersion();
+        if (version) {
+            const localVersion = force ? null : await this.findLocalVersion(version);
+            if (this.alreadyOnVersion(current, localVersion || null)) {
+                core_1.CliUx.ux.action.stop(this.config.scopedEnvVar('HIDE_UPDATED_MESSAGE') ? 'done' : `already on version ${current}`);
+                return;
+            }
+            await this.config.runHook('preupdate', { channel, version });
+            if (localVersion) {
+                await this.updateToExistingVersion(current, localVersion);
             }
-            core_1.CliUx.ux.action.start(`${this.options.config.name}: Updating CLI`);
-            core_1.CliUx.ux.debug(`switching to existing version ${pinToVersion}`);
-            this.updateToExistingVersion(pinToVersion);
+            else {
+                const index = await this.fetchVersionIndex();
+                const url = index[version];
+                if (!url) {
+                    throw new Error(`${version} not found in index:\n${Object.keys(index).join(', ')}`);
+                }
+                const manifest = await this.fetchVersionManifest(version, url);
+                const updated = manifest.sha ? `${manifest.version}-${manifest.sha}` : manifest.version;
+                await this.update(manifest, current, updated, force, channel);
+            }
+            await this.config.runHook('update', { channel, version });
+            core_1.CliUx.ux.action.stop();
             core_1.CliUx.ux.log();
-            core_1.CliUx.ux.log(`Updating to an already installed version will not update the channel. If autoupdate is enabled, the CLI will eventually be updated back to ${this.channel}.`);
+            core_1.CliUx.ux.log(`Updating to a specific version will not update the channel. If autoupdate is enabled, the CLI will eventually be updated back to ${channel}.`);
         }
         else {
-            core_1.CliUx.ux.action.start(`${this.options.config.name}: Updating CLI`);
-            await this.options.config.runHook('preupdate', { channel: this.channel });
-            const manifest = await this.fetchManifest();
-            this.currentVersion = await this.determineCurrentVersion();
-            this.updatedVersion = manifest.sha ? `${manifest.version}-${manifest.sha}` : manifest.version;
-            const reason = await this.skipUpdate();
-            if (reason)
-                core_1.CliUx.ux.action.stop(reason || 'done');
-            else
-                await this.update(manifest);
-            core_1.CliUx.ux.debug('tidy');
-            await this.tidy();
-            await this.options.config.runHook('update', { channel: this.channel });
+            const manifest = await this.fetchChannelManifest(channel);
+            const updated = manifest.sha ? `${manifest.version}-${manifest.sha}` : manifest.version;
+            if (!force && this.alreadyOnVersion(current, updated)) {
+                core_1.CliUx.ux.action.stop(this.config.scopedEnvVar('HIDE_UPDATED_MESSAGE') ? 'done' : `already on version ${current}`);
+            }
+            else {
+                await this.config.runHook('preupdate', { channel, version: updated });
+                await this.update(manifest, current, updated, force, channel);
+            }
+            await this.config.runHook('update', { channel, version: updated });
+            core_1.CliUx.ux.action.stop();
         }
+        await this.touch();
+        await this.tidy();
         core_1.CliUx.ux.debug('done');
-        core_1.CliUx.ux.action.stop();
     }
-    async fetchManifest() {
-        const http = require('http-call').HTTP;
-        core_1.CliUx.ux.action.status = 'fetching manifest';
+    async findLocalVersions() {
+        await this.ensureClientDir();
+        return fs
+            .readdirSync(this.clientRoot)
+            .filter(dirOrFile => dirOrFile !== 'bin' && dirOrFile !== 'current')
+            .map(f => path.join(this.clientRoot, f));
+    }
+    async fetchVersionIndex() {
+        core_1.CliUx.ux.action.status = 'fetching version index';
+        const newIndexUrl = this.config.s3Url(this.s3VersionIndexKey());
         try {
-            const url = this.options.config.s3Url(this.options.config.s3Key('manifest', {
-                channel: this.channel,
-                platform: this.options.config.platform,
-                arch: this.options.config.arch,
-            }));
-            const { body } = await http.get(url);
-            // in case the content-type is not set, parse as a string
-            // this will happen if uploading without `oclif-dev publish`
+            const { body } = await http_call_1.default.get(newIndexUrl);
             if (typeof body === 'string') {
                 return JSON.parse(body);
             }
             return body;
         }
+        catch (_a) {
+            throw new Error(`No version indices exist for ${this.config.name}.`);
+        }
+    }
+    async ensureClientDir() {
+        try {
+            await fs.mkdirp(this.clientRoot);
+        }
+        catch (error) {
+            if (error.code === 'EEXIST') {
+                // for some reason the client directory is sometimes a file
+                // if so, this happens. Delete it and recreate
+                await fs.remove(this.clientRoot);
+                await fs.mkdirp(this.clientRoot);
+            }
+            else {
+                throw error;
+            }
+        }
+    }
+    composeS3SubDir() {
+        let s3SubDir = this.config.pjson.oclif.update.s3.folder || '';
+        if (s3SubDir !== '' && s3SubDir.slice(-1) !== '/')
+            s3SubDir = `${s3SubDir}/`;
+        return s3SubDir;
+    }
+    s3ChannelManifestKey(channel) {
+        const { bin, platform, arch } = this.config;
+        const s3SubDir = this.composeS3SubDir();
+        return path.join(s3SubDir, 'channels', channel, `${bin}-${platform}-${arch}-buildmanifest`);
+    }
+    s3VersionManifestKey(version, hash) {
+        const { bin, platform, arch } = this.config;
+        const s3SubDir = this.composeS3SubDir();
+        return path.join(s3SubDir, 'versions', version, hash, `${bin}-v${version}-${hash}-${platform}-${arch}-buildmanifest`);
+    }
+    s3VersionIndexKey() {
+        const { bin, platform, arch } = this.config;
+        const s3SubDir = this.composeS3SubDir();
+        return path.join(s3SubDir, 'versions', `${bin}-${platform}-${arch}-tar-gz.json`);
+    }
+    async fetchChannelManifest(channel) {
+        const s3Key = this.s3ChannelManifestKey(channel);
+        try {
+            return await this.fetchManifest(s3Key);
+        }
         catch (error) {
             if (error.statusCode === 403)
-                throw new Error(`HTTP 403: Invalid channel ${this.channel}`);
+                throw new Error(`HTTP 403: Invalid channel ${channel}`);
             throw error;
         }
     }
+    async fetchVersionManifest(version, url) {
+        const parts = url.split('/');
+        const hashIndex = parts.indexOf(version) + 1;
+        const hash = parts[hashIndex];
+        const s3Key = this.s3VersionManifestKey(version, hash);
+        return this.fetchManifest(s3Key);
+    }
+    async fetchManifest(s3Key) {
+        core_1.CliUx.ux.action.status = 'fetching manifest';
+        const url = this.config.s3Url(s3Key);
+        const { body } = await http_call_1.default.get(url);
+        if (typeof body === 'string') {
+            return JSON.parse(body);
+        }
+        return body;
+    }
     async downloadAndExtract(output, manifest, channel) {
         const { version, gz, sha256gz } = manifest;
-        const filesize = (n) => {
-            const [num, suffix] = require('filesize')(n, { output: 'array' });
-            return num.toFixed(1) + ` ${suffix}`;
-        };
-        const http = require('http-call').HTTP;
-        const gzUrl = gz || this.options.config.s3Url(this.options.config.s3Key('versioned', {
+        const gzUrl = gz || this.config.s3Url(this.config.s3Key('versioned', {
             version,
             channel,
-            bin: this.options.config.bin,
-            platform: this.options.config.platform,
-            arch: this.options.config.arch,
+            bin: this.config.bin,
+            platform: this.config.platform,
+            arch: this.config.arch,
             ext: 'gz',
         }));
-        const { response: stream } = await http.stream(gzUrl);
+        const { response: stream } = await http_call_1.default.stream(gzUrl);
         stream.pause();
-        const baseDir = manifest.baseDir || this.options.config.s3Key('baseDir', {
+        const baseDir = manifest.baseDir || this.config.s3Key('baseDir', {
             version,
             channel,
-            bin: this.options.config.bin,
-            platform: this.options.config.platform,
-            arch: this.options.config.arch,
+            bin: this.config.bin,
+            platform: this.config.platform,
+            arch: this.config.arch,
         });
         const extraction = (0, tar_1.extract)(stream, baseDir, output, sha256gz);
-        // to-do: use cli.action.type
-        if (core_1.CliUx.ux.action.frames) {
-            // if spinner action
+        if (core_1.CliUx.ux.action.type === 'spinner') {
             const total = Number.parseInt(stream.headers['content-length'], 10);
             let current = 0;
-            const updateStatus = _.throttle((newStatus) => {
+            const updateStatus = (0, lodash_throttle_1.default)((newStatus) => {
                 core_1.CliUx.ux.action.status = newStatus;
             }, 250, { leading: true, trailing: false });
             stream.on('data', data => {
@@ -121,70 +194,69 @@ class UpdateCli {
         stream.resume();
         await extraction;
     }
-    async update(manifest, channel = 'stable') {
-        core_1.CliUx.ux.action.start(`${this.options.config.name}: Updating CLI from ${color_1.default.green(this.currentVersion)} to ${color_1.default.green(this.updatedVersion)}${channel === 'stable' ? '' : ' (' + color_1.default.yellow(channel) + ')'}`);
+    // eslint-disable-next-line max-params
+    async update(manifest, current, updated, force, channel) {
+        core_1.CliUx.ux.action.start(`${this.config.name}: Updating CLI from ${color_1.default.green(current)} to ${color_1.default.green(updated)}${channel === 'stable' ? '' : ' (' + color_1.default.yellow(channel) + ')'}`);
         await this.ensureClientDir();
-        const output = path.join(this.clientRoot, this.updatedVersion);
-        if (!await fs.pathExists(output)) {
+        const output = path.join(this.clientRoot, updated);
+        if (force || !await fs.pathExists(output))
             await this.downloadAndExtract(output, manifest, channel);
-        }
-        await this.setChannel();
-        await this.createBin(this.updatedVersion);
-        await this.touch();
-        await this.reexec();
+        await this.refreshConfig(updated);
+        await this.setChannel(channel);
+        await this.createBin(updated);
     }
-    async updateToExistingVersion(version) {
-        await this.createBin(version);
-        await this.touch();
+    async updateToExistingVersion(current, updated) {
+        core_1.CliUx.ux.action.start(`${this.config.name}: Updating CLI from ${color_1.default.green(current)} to ${color_1.default.green(updated)}`);
+        await this.ensureClientDir();
+        await this.refreshConfig(updated);
+        await this.createBin(updated);
     }
-    async skipUpdate() {
-        if (!this.options.config.binPath) {
-            const instructions = this.options.config.scopedEnvVar('UPDATE_INSTRUCTIONS');
+    notUpdatable() {
+        if (!this.config.binPath) {
+            const instructions = this.config.scopedEnvVar('UPDATE_INSTRUCTIONS');
             if (instructions)
                 core_1.CliUx.ux.warn(instructions);
-            return 'not updatable';
-        }
-        if (this.currentVersion === this.updatedVersion) {
-            if (this.options.config.scopedEnvVar('HIDE_UPDATED_MESSAGE'))
-                return 'done';
-            return `already on latest version: ${this.currentVersion}`;
+            return true;
         }
         return false;
     }
+    alreadyOnVersion(current, updated) {
+        return current === updated;
+    }
     async determineChannel() {
-        const channelPath = path.join(this.options.config.dataDir, 'channel');
+        const channelPath = path.join(this.config.dataDir, 'channel');
         if (fs.existsSync(channelPath)) {
             const channel = await fs.readFile(channelPath, 'utf8');
             return String(channel).trim();
         }
-        return this.options.config.channel || 'stable';
+        return this.config.channel || 'stable';
     }
     async determineCurrentVersion() {
         try {
             const currentVersion = await fs.readFile(this.clientBin, 'utf8');
             const matches = currentVersion.match(/\.\.[/\\|](.+)[/\\|]bin/);
-            return matches ? matches[1] : this.options.config.version;
+            return matches ? matches[1] : this.config.version;
         }
         catch (error) {
             core_1.CliUx.ux.debug(error);
         }
-        return this.options.config.version;
+        return this.config.version;
     }
-    s3ChannelManifestKey(bin, platform, arch, folder = '') {
-        let s3SubDir = folder || '';
-        if (s3SubDir !== '' && s3SubDir.slice(-1) !== '/')
-            s3SubDir = `${s3SubDir}/`;
-        return path.join(s3SubDir, 'channels', this.channel, `${bin}-${platform}-${arch}-buildmanifest`);
+    async findLocalVersion(version) {
+        const versions = await this.findLocalVersions();
+        return versions
+            .map(file => path.basename(file))
+            .find(file => file.startsWith(version));
     }
-    async setChannel() {
-        const channelPath = path.join(this.options.config.dataDir, 'channel');
-        fs.writeFile(channelPath, this.channel, 'utf8');
+    async setChannel(channel) {
+        const channelPath = path.join(this.config.dataDir, 'channel');
+        fs.writeFile(channelPath, channel, 'utf8');
     }
     async logChop() {
         try {
             core_1.CliUx.ux.debug('log chop');
             const logChopper = require('log-chopper').default;
-            await logChopper.chop(this.options.config.errlog);
+            await logChopper.chop(this.config.errlog);
         }
         catch (error) {
             core_1.CliUx.ux.debug(error.message);
@@ -197,7 +269,7 @@ class UpdateCli {
     // when autoupdating, wait until the CLI isn't active
     async debounce() {
         let output = false;
-        const lastrunfile = path.join(this.options.config.cacheDir, 'lastrun');
+        const lastrunfile = path.join(this.config.cacheDir, 'lastrun');
         const m = await this.mtime(lastrunfile);
         m.setHours(m.getHours() + 1);
         if (m > new Date()) {
@@ -206,7 +278,7 @@ class UpdateCli {
                 core_1.CliUx.ux.debug(msg);
             }
             else {
-                await core_1.CliUx.ux.log(msg);
+                core_1.CliUx.ux.log(msg);
                 output = true;
             }
             await (0, util_1.wait)(60 * 1000); // wait 1 minute
@@ -216,13 +288,14 @@ class UpdateCli {
     }
     // removes any unused CLIs
     async tidy() {
+        core_1.CliUx.ux.debug('tidy');
         try {
             const root = this.clientRoot;
             if (!await fs.pathExists(root))
                 return;
             const files = await (0, util_1.ls)(root);
             const promises = files.map(async (f) => {
-                if (['bin', 'current', this.options.config.version].includes(path.basename(f.path)))
+                if (['bin', 'current', this.config.version].includes(path.basename(f.path)))
                     return;
                 const mtime = f.stat.mtime;
                 mtime.setHours(mtime.getHours() + (42 * 24));
@@ -241,7 +314,7 @@ class UpdateCli {
     async touch() {
         // touch the client so it won't be tidied up right away
         try {
-            const p = path.join(this.clientRoot, this.options.config.version);
+            const p = path.join(this.clientRoot, this.config.version);
             core_1.CliUx.ux.debug('touching client at', p);
             if (!await fs.pathExists(p))
                 return;
@@ -251,31 +324,14 @@ class UpdateCli {
             core_1.CliUx.ux.warn(error);
         }
     }
-    async reexec() {
-        core_1.CliUx.ux.action.stop();
-        return new Promise((_, reject) => {
-            core_1.CliUx.ux.debug('restarting CLI after update', this.clientBin);
-            spawn(this.clientBin, ['update'], {
-                stdio: 'inherit',
-                env: Object.assign(Object.assign({}, process.env), { [this.options.config.scopedEnvVarKey('HIDE_UPDATED_MESSAGE')]: '1' }),
-            })
-                .on('error', reject)
-                .on('close', (status) => {
-                try {
-                    if (status > 0)
-                        this.options.exit(status);
-                }
-                catch (error) {
-                    reject(error);
-                }
-            });
-        });
+    async refreshConfig(version) {
+        this.config = await core_1.Config.load({ root: path.join(this.clientRoot, version) });
     }
     async createBin(version) {
         const dst = this.clientBin;
-        const { bin, windows } = this.options.config;
-        const binPathEnvVar = this.options.config.scopedEnvVarKey('BINPATH');
-        const redirectedEnvVar = this.options.config.scopedEnvVarKey('REDIRECTED');
+        const { bin, windows } = this.config;
+        const binPathEnvVar = this.config.scopedEnvVarKey('BINPATH');
+        const redirectedEnvVar = this.config.scopedEnvVarKey('REDIRECTED');
         if (windows) {
             const body = `@echo off
 setlocal enableextensions
@@ -312,21 +368,5 @@ ${binPathEnvVar}="\$DIR/${bin}" ${redirectedEnvVar}=1 "$DIR/../${version}/bin/${
             await fs.symlink(`./${version}`, path.join(this.clientRoot, 'current'));
         }
     }
-    async ensureClientDir() {
-        try {
-            await fs.mkdirp(this.clientRoot);
-        }
-        catch (error) {
-            if (error.code === 'EEXIST') {
-                // for some reason the client directory is sometimes a file
-                // if so, this happens. Delete it and recreate
-                await fs.remove(this.clientRoot);
-                await fs.mkdirp(this.clientRoot);
-            }
-            else {
-                throw error;
-            }
-        }
-    }
 }
-exports.default = UpdateCli;
+exports.Updater = Updater;

package/lib/util.d.ts

@@ -1,8 +1,9 @@
 /// <reference types="node" />
 import * as fs from 'fs-extra';
 export declare function touch(p: string): Promise<void>;
-export declare function ls(dir: string): Promise<{
+export declare function ls(dir: string): Promise<Array<{
     path: string;
     stat: fs.Stats;
-}[]>;
+}>>;
+export declare function rm(dir: string): Promise<void>;
 export declare function wait(ms: number, unref?: boolean): Promise<void>;

package/lib/util.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.wait = exports.ls = exports.touch = void 0;
-const fs = require("fs-extra");
-const path = require("path");
+exports.wait = exports.rm = exports.ls = exports.touch = void 0;
+const tslib_1 = require("tslib");
+const fs = (0, tslib_1.__importStar)(require("fs-extra"));
+const path = (0, tslib_1.__importStar)(require("path"));
 async function touch(p) {
     try {
         await fs.utimes(p, new Date(), new Date());
@@ -18,6 +19,14 @@ async function ls(dir) {
     return Promise.all(paths.map(path => fs.stat(path).then(stat => ({ path, stat }))));
 }
 exports.ls = ls;
+async function rm(dir) {
+    return new Promise(resolve => {
+        fs.rm(dir, { recursive: true, force: true }, () => {
+            resolve();
+        });
+    });
+}
+exports.rm = rm;
 function wait(ms, unref = false) {
     return new Promise(resolve => {
         const t = setTimeout(() => resolve(), ms);

package/oclif.manifest.json

@@ -1 +1 @@
-{"version":"2.2.0","commands":{"update":{"id":"update","description":"update the <%= config.bin %> CLI","strict":true,"pluginName":"@oclif/plugin-update","pluginAlias":"@oclif/plugin-update","pluginType":"core","aliases":[],"flags":{"autoupdate":{"name":"autoupdate","type":"boolean","hidden":true,"allowNo":false},"from-local":{"name":"from-local","type":"boolean","description":"interactively choose an already installed version","allowNo":false}},"args":[{"name":"channel"}]}}}
+{"version":"3.0.0","commands":{"update":{"id":"update","description":"update the <%= config.bin %> CLI","strict":true,"pluginName":"@oclif/plugin-update","pluginAlias":"@oclif/plugin-update","pluginType":"core","aliases":[],"examples":[{"description":"Update to the stable channel:","command":"<%= config.bin %> <%= command.id %> stable"},{"description":"Update to a specific version:","command":"<%= config.bin %> <%= command.id %> --version 1.0.0"},{"description":"Interactively select version:","command":"<%= config.bin %> <%= command.id %> --interactive"},{"description":"See available versions:","command":"<%= config.bin %> <%= command.id %> --available"}],"flags":{"autoupdate":{"name":"autoupdate","type":"boolean","hidden":true,"allowNo":false},"available":{"name":"available","type":"boolean","char":"a","description":"Install a specific version.","allowNo":false},"version":{"name":"version","type":"option","char":"v","description":"Install a specific version.","multiple":false,"exclusive":["interactive"]},"interactive":{"name":"interactive","type":"boolean","char":"i","description":"Interactively select version to install. This is ignored if a channel is provided.","allowNo":false,"exclusive":["version"]},"force":{"name":"force","type":"boolean","description":"Force a re-download of the requested version.","allowNo":false}},"args":[{"name":"channel"}]}}}

package/package.json

@@ -1,18 +1,18 @@
 {
   "name": "@oclif/plugin-update",
-  "version": "2.2.0",
+  "version": "3.0.0",
   "author": "Salesforce",
   "bugs": "https://github.com/oclif/plugin-update/issues",
   "dependencies": {
     "@oclif/color": "^1.0.0",
-    "@oclif/core": "^1.2.0",
-    "@types/semver": "^7.3.4",
+    "@oclif/core": "^1.3.0",
     "cross-spawn": "^7.0.3",
     "debug": "^4.3.1",
     "filesize": "^6.1.0",
     "fs-extra": "^9.0.1",
     "http-call": "^5.3.0",
-    "lodash": "^4.17.21",
+    "inquirer": "^8.2.0",
+    "lodash.throttle": "^4.1.1",
     "log-chopper": "^1.0.2",
     "semver": "^7.3.5",
     "tar-fs": "^2.1.1"
@@ -25,9 +25,11 @@
     "@types/execa": "^0.9.0",
     "@types/fs-extra": "^8.0.1",
     "@types/glob": "^7.1.3",
-    "@types/lodash": "^4.14.168",
+    "@types/inquirer": "^8.2.0",
+    "@types/lodash.throttle": "^4.1.6",
     "@types/mocha": "^9",
     "@types/node": "^14.14.31",
+    "@types/semver": "^7.3.4",
     "@types/supports-color": "^7.2.0",
     "@types/write-json-file": "^3.2.1",
     "chai": "^4.3.4",
@@ -37,7 +39,7 @@
     "globby": "^11.0.2",
     "mocha": "^9",
     "nock": "^13.2.1",
-    "oclif": "^2.3.0",
+    "oclif": "^2.4.2",
     "qqjs": "^0.3.11",
     "sinon": "^12.0.1",
     "ts-node": "^9.1.1",