@oclif/plugin-update 4.0.1-qa.0 → 4.1.1

package/{lib → dist}/update.js

@@ -1,45 +1,61 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Updater = void 0;
-const tslib_1 = require("tslib");
-/* eslint-disable unicorn/prefer-module */
-const core_1 = require("@oclif/core");
-const chalk_1 = require("chalk");
-const node_fs_1 = require("node:fs");
-const promises_1 = require("node:fs/promises");
-const http_call_1 = tslib_1.__importDefault(require("http-call"));
-const path = tslib_1.__importStar(require("path"));
-const lodash_throttle_1 = tslib_1.__importDefault(require("lodash.throttle"));
-const filesize_1 = tslib_1.__importDefault(require("filesize"));
-const tar_1 = require("./tar");
-const util_1 = require("./util");
+import { Config, ux } from '@oclif/core';
+import chalk from 'chalk';
+import fileSize from 'filesize';
+import { HTTP } from 'http-call';
+import throttle from 'lodash.throttle';
+import { existsSync } from 'node:fs';
+import { mkdir, readFile, readdir, rm, stat, symlink, utimes, writeFile } from 'node:fs/promises';
+import { basename, dirname, join } from 'node:path';
+import { Extractor } from './tar.js';
+import { ls, wait } from './util.js';
 const filesize = (n) => {
-    const [num, suffix] = (0, filesize_1.default)(n, { output: 'array' });
+    const [num, suffix] = fileSize(n, { output: 'array' });
     return Number.parseFloat(num).toFixed(1) + ` ${suffix}`;
 };
-class Updater {
+export class Updater {
+    config;
+    clientBin;
+    clientRoot;
     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);
+        this.clientRoot = config.scopedEnvVar('OCLIF_CLIENT_HOME') ?? join(config.dataDir, 'client');
+        this.clientBin = join(this.clientRoot, 'bin', config.windows ? `${config.bin}.cmd` : config.bin);
+    }
+    async fetchVersionIndex() {
+        ux.action.status = 'fetching version index';
+        const newIndexUrl = this.config.s3Url(s3VersionIndexKey(this.config));
+        try {
+            const { body } = await HTTP.get(newIndexUrl);
+            return typeof body === 'string' ? JSON.parse(body) : body;
+        }
+        catch {
+            throw new Error(`No version indices exist for ${this.config.name}.`);
+        }
+    }
+    async findLocalVersions() {
+        await ensureClientDir(this.clientRoot);
+        const dirOrFiles = await readdir(this.clientRoot);
+        return dirOrFiles
+            .filter((dirOrFile) => dirOrFile !== 'bin' && dirOrFile !== 'current')
+            .map((f) => join(this.clientRoot, f));
     }
     async runUpdate(options) {
-        const { autoUpdate, version, force = false } = options;
+        const { autoUpdate, force = false, version } = options;
         if (autoUpdate)
             await debounce(this.config.cacheDir);
-        core_1.ux.action.start(`${this.config.name}: Updating CLI`);
+        ux.action.start(`${this.config.name}: Updating CLI`);
         if (notUpdatable(this.config)) {
-            core_1.ux.action.stop('not updatable');
+            ux.action.stop('not updatable');
             return;
         }
         const [channel, current] = await Promise.all([
-            options.channel ?? determineChannel({ version, config: this.config }),
+            options.channel ?? determineChannel({ config: this.config, version }),
             determineCurrentVersion(this.clientBin, this.config.version),
         ]);
         if (version) {
             const localVersion = force ? null : await this.findLocalVersion(version);
             if (alreadyOnVersion(current, localVersion || null)) {
-                core_1.ux.action.stop(this.config.scopedEnvVar('HIDE_UPDATED_MESSAGE') ? 'done' : `already on version ${current}`);
+                ux.action.stop(this.config.scopedEnvVar('HIDE_UPDATED_MESSAGE') ? 'done' : `already on version ${current}`);
                 return;
             }
             await this.config.runHook('preupdate', { channel, version });
@@ -57,121 +73,33 @@ class Updater {
                 await this.update(manifest, current, updated, force, channel);
             }
             await this.config.runHook('update', { channel, version });
-            core_1.ux.action.stop();
-            core_1.ux.log();
-            core_1.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}.`);
+            ux.action.stop();
+            ux.log();
+            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 {
             const manifest = await fetchChannelManifest(channel, this.config);
             const updated = manifest.sha ? `${manifest.version}-${manifest.sha}` : manifest.version;
             if (!force && alreadyOnVersion(current, updated)) {
-                core_1.ux.action.stop(this.config.scopedEnvVar('HIDE_UPDATED_MESSAGE') ? 'done' : `already on version ${current}`);
+                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.ux.action.stop();
+            ux.action.stop();
         }
         await this.touch();
         await this.tidy();
-        core_1.ux.debug('done');
-    }
-    async findLocalVersions() {
-        await ensureClientDir(this.clientRoot);
-        return (await (0, promises_1.readdir)(this.clientRoot))
-            .filter(dirOrFile => dirOrFile !== 'bin' && dirOrFile !== 'current')
-            .map(f => path.join(this.clientRoot, f));
-    }
-    async fetchVersionIndex() {
-        core_1.ux.action.status = 'fetching version index';
-        const newIndexUrl = this.config.s3Url(s3VersionIndexKey(this.config));
-        try {
-            const { body } = await http_call_1.default.get(newIndexUrl);
-            if (typeof body === 'string') {
-                return JSON.parse(body);
-            }
-            return body;
-        }
-        catch {
-            throw new Error(`No version indices exist for ${this.config.name}.`);
-        }
-    }
-    async fetchVersionManifest(version, url) {
-        const parts = url.split('/');
-        const hashIndex = parts.indexOf(version) + 1;
-        const hash = parts[hashIndex];
-        const s3Key = s3VersionManifestKey({ version, hash, config: this.config });
-        return fetchManifest(s3Key, this.config);
-    }
-    // eslint-disable-next-line max-params
-    async update(manifest, current, updated, force, channel) {
-        core_1.ux.action.start(`${this.config.name}: Updating CLI from ${(0, chalk_1.green)(current)} to ${(0, chalk_1.green)(updated)}${channel === 'stable' ? '' : ' (' + (0, chalk_1.yellow)(channel) + ')'}`);
-        await ensureClientDir(this.clientRoot);
-        const output = path.join(this.clientRoot, updated);
-        if (force || !(0, node_fs_1.existsSync)(output))
-            await downloadAndExtract(output, manifest, channel, this.config);
-        await this.refreshConfig(updated);
-        await setChannel(channel, this.config.dataDir);
-        await this.createBin(updated);
-    }
-    async updateToExistingVersion(current, updated) {
-        core_1.ux.action.start(`${this.config.name}: Updating CLI from ${(0, chalk_1.green)(current)} to ${(0, chalk_1.green)(updated)}`);
-        await ensureClientDir(this.clientRoot);
-        await this.refreshConfig(updated);
-        await this.createBin(updated);
-    }
-    async findLocalVersion(version) {
-        const versions = await this.findLocalVersions();
-        return versions
-            .map(file => path.basename(file))
-            .find(file => file.startsWith(version));
-    }
-    // removes any unused CLIs
-    async tidy() {
-        core_1.ux.debug('tidy');
-        try {
-            const root = this.clientRoot;
-            if (!(0, node_fs_1.existsSync)(root))
-                return;
-            const files = await (0, util_1.ls)(root);
-            const isNotSpecial = (fPath, version) => !(['bin', 'current', version].includes(path.basename(fPath)));
-            const isOld = (fStat) => {
-                const mtime = fStat.mtime;
-                mtime.setHours(mtime.getHours() + (42 * 24));
-                return mtime < new Date();
-            };
-            await Promise.all(files.filter(f => isNotSpecial(this.config.version, f.path) && isOld(f.stat))
-                .map(f => (0, promises_1.rm)(f.path, { recursive: true, force: true })));
-            await logChop(this.config.errlog);
-        }
-        catch (error) {
-            core_1.ux.warn(error);
-        }
-    }
-    async touch() {
-        // touch the client so it won't be tidied up right away
-        try {
-            const p = path.join(this.clientRoot, this.config.version);
-            core_1.ux.debug('touching client at', p);
-            if (!(0, node_fs_1.existsSync)(p))
-                return;
-            return (0, promises_1.utimes)(p, new Date(), new Date());
-        }
-        catch (error) {
-            core_1.ux.warn(error);
-        }
-    }
-    async refreshConfig(version) {
-        this.config = await core_1.Config.load({ root: path.join(this.clientRoot, version) });
+        ux.debug('done');
     }
     async createBin(version) {
         const dst = this.clientBin;
         const { bin, windows } = this.config;
         const binPathEnvVar = this.config.scopedEnvVarKey('BINPATH');
         const redirectedEnvVar = this.config.scopedEnvVarKey('REDIRECTED');
-        await (0, promises_1.mkdir)(path.dirname(dst), { recursive: true });
+        await mkdir(dirname(dst), { recursive: true });
         if (windows) {
             const body = `@echo off
 setlocal enableextensions
@@ -179,7 +107,7 @@ set ${redirectedEnvVar}=1
 set ${binPathEnvVar}=%~dp0${bin}
 "%~dp0..\\${version}\\bin\\${bin}.cmd" %*
 `;
-            await (0, promises_1.writeFile)(dst, body);
+            await writeFile(dst, body);
         }
         else {
             /* eslint-disable no-useless-escape */
@@ -201,36 +129,103 @@ DIR=$(get_script_dir)
 ${binPathEnvVar}="\$DIR/${bin}" ${redirectedEnvVar}=1 "$DIR/../${version}/bin/${bin}" "$@"
 `;
             /* eslint-enable no-useless-escape */
-            await (0, promises_1.writeFile)(dst, body, { mode: 0o755 });
-            await (0, promises_1.rm)(path.join(this.clientRoot, 'current'), { recursive: true, force: true });
-            await (0, promises_1.symlink)(`./${version}`, path.join(this.clientRoot, 'current'));
+            await writeFile(dst, body, { mode: 0o755 });
+            await rm(join(this.clientRoot, 'current'), { force: true, recursive: true });
+            await symlink(`./${version}`, join(this.clientRoot, 'current'));
+        }
+    }
+    async fetchVersionManifest(version, url) {
+        const parts = url.split('/');
+        const hashIndex = parts.indexOf(version) + 1;
+        const hash = parts[hashIndex];
+        const s3Key = s3VersionManifestKey({ config: this.config, hash, version });
+        return fetchManifest(s3Key, this.config);
+    }
+    async findLocalVersion(version) {
+        const versions = await this.findLocalVersions();
+        return versions.map((file) => basename(file)).find((file) => file.startsWith(version));
+    }
+    async refreshConfig(version) {
+        this.config = (await Config.load({ root: join(this.clientRoot, version) }));
+    }
+    // removes any unused CLIs
+    async tidy() {
+        ux.debug('tidy');
+        try {
+            const root = this.clientRoot;
+            if (!existsSync(root))
+                return;
+            const files = await ls(root);
+            const isNotSpecial = (fPath, version) => !['bin', 'current', version].includes(basename(fPath));
+            const isOld = (fStat) => {
+                const { mtime } = fStat;
+                mtime.setHours(mtime.getHours() + 42 * 24);
+                return mtime < new Date();
+            };
+            await Promise.all(files
+                .filter((f) => isNotSpecial(this.config.version, f.path) && isOld(f.stat))
+                .map((f) => rm(f.path, { force: true, recursive: true })));
+        }
+        catch (error) {
+            ux.warn(error);
         }
     }
+    async touch() {
+        // touch the client so it won't be tidied up right away
+        try {
+            const p = join(this.clientRoot, this.config.version);
+            ux.debug('touching client at', p);
+            if (!existsSync(p))
+                return;
+            return utimes(p, new Date(), new Date());
+        }
+        catch (error) {
+            ux.warn(error);
+        }
+    }
+    // eslint-disable-next-line max-params
+    async update(manifest, current, updated, force, channel) {
+        ux.action.start(`${this.config.name}: Updating CLI from ${chalk.green(current)} to ${chalk.green(updated)}${channel === 'stable' ? '' : ' (' + chalk.yellow(channel) + ')'}`);
+        await ensureClientDir(this.clientRoot);
+        const output = join(this.clientRoot, updated);
+        if (force || !existsSync(output))
+            await downloadAndExtract(output, manifest, channel, this.config);
+        await this.refreshConfig(updated);
+        await setChannel(channel, this.config.dataDir);
+        await this.createBin(updated);
+    }
+    async updateToExistingVersion(current, updated) {
+        ux.action.start(`${this.config.name}: Updating CLI from ${chalk.green(current)} to ${chalk.green(updated)}`);
+        await ensureClientDir(this.clientRoot);
+        await this.refreshConfig(updated);
+        await this.createBin(updated);
+    }
 }
-exports.Updater = Updater;
 const alreadyOnVersion = (current, updated) => current === updated;
 const ensureClientDir = async (clientRoot) => {
     try {
-        await (0, promises_1.mkdir)(clientRoot, { recursive: true });
+        await mkdir(clientRoot, { recursive: true });
     }
     catch (error) {
-        if (error.code === 'EEXIST') {
+        const { code } = error;
+        if (code === 'EEXIST') {
             // for some reason the client directory is sometimes a file
             // if so, this happens. Delete it and recreate
-            await (0, promises_1.rm)(clientRoot, { recursive: true, force: true });
-            await (0, promises_1.mkdir)(clientRoot, { recursive: true });
+            await rm(clientRoot, { force: true, recursive: true });
+            await mkdir(clientRoot, { recursive: true });
         }
         else {
             throw error;
         }
     }
 };
-const mtime = async (f) => (await (0, promises_1.stat)(f)).mtime;
+// eslint-disable-next-line unicorn/no-await-expression-member
+const mtime = async (f) => (await stat(f)).mtime;
 const notUpdatable = (config) => {
     if (!config.binPath) {
         const instructions = config.scopedEnvVar('UPDATE_INSTRUCTIONS');
         if (instructions)
-            core_1.ux.warn(instructions);
+            ux.warn(instructions);
         return true;
     }
     return false;
@@ -242,89 +237,92 @@ const composeS3SubDir = (config) => {
     return s3SubDir;
 };
 const fetchManifest = async (s3Key, config) => {
-    core_1.ux.action.status = 'fetching manifest';
+    ux.action.status = 'fetching manifest';
     const url = config.s3Url(s3Key);
-    const { body } = await http_call_1.default.get(url);
+    const { body } = await HTTP.get(url);
     if (typeof body === 'string') {
         return JSON.parse(body);
     }
     return body;
 };
 const s3VersionIndexKey = (config) => {
-    const { bin, arch } = config;
+    const { arch, bin } = config;
     const s3SubDir = composeS3SubDir(config);
-    return path.join(s3SubDir, 'versions', `${bin}-${determinePlatform(config)}-${arch}-tar-gz.json`);
+    return join(s3SubDir, 'versions', `${bin}-${determinePlatform(config)}-${arch}-tar-gz.json`);
 };
 const determinePlatform = (config) => config.platform === 'wsl' ? 'linux' : config.platform;
 const s3ChannelManifestKey = (channel, config) => {
-    const { bin, arch } = config;
+    const { arch, bin } = config;
     const s3SubDir = composeS3SubDir(config);
-    return path.join(s3SubDir, 'channels', channel, `${bin}-${determinePlatform(config)}-${arch}-buildmanifest`);
+    return join(s3SubDir, 'channels', channel, `${bin}-${determinePlatform(config)}-${arch}-buildmanifest`);
 };
-const s3VersionManifestKey = ({ version, hash, config }) => {
-    const { bin, arch } = config;
+const s3VersionManifestKey = ({ config, hash, version }) => {
+    const { arch, bin } = config;
     const s3SubDir = composeS3SubDir(config);
-    return path.join(s3SubDir, 'versions', version, hash, `${bin}-v${version}-${hash}-${determinePlatform(config)}-${arch}-buildmanifest`);
+    return join(s3SubDir, 'versions', version, hash, `${bin}-v${version}-${hash}-${determinePlatform(config)}-${arch}-buildmanifest`);
 };
 // when autoupdating, wait until the CLI isn't active
 const debounce = async (cacheDir) => {
     let output = false;
-    const lastrunfile = path.join(cacheDir, 'lastrun');
+    const lastrunfile = join(cacheDir, 'lastrun');
     const m = await mtime(lastrunfile);
     m.setHours(m.getHours() + 1);
     if (m > new Date()) {
         const msg = `waiting until ${m.toISOString()} to update`;
         if (output) {
-            core_1.ux.debug(msg);
+            ux.debug(msg);
         }
         else {
-            core_1.ux.log(msg);
+            ux.log(msg);
             output = true;
         }
-        await (0, util_1.wait)(60 * 1000); // wait 1 minute
+        await wait(60 * 1000); // wait 1 minute
         return debounce(cacheDir);
     }
-    core_1.ux.log('time to update');
+    ux.log('time to update');
 };
-const setChannel = async (channel, dataDir) => (0, promises_1.writeFile)(path.join(dataDir, 'channel'), channel, 'utf8');
+const setChannel = async (channel, dataDir) => writeFile(join(dataDir, 'channel'), channel, 'utf8');
 const fetchChannelManifest = async (channel, config) => {
     const s3Key = s3ChannelManifestKey(channel, config);
     try {
         return await fetchManifest(s3Key, config);
     }
     catch (error) {
-        if (error.statusCode === 403)
+        const { statusCode } = error;
+        if (statusCode === 403)
             throw new Error(`HTTP 403: Invalid channel ${channel}`);
         throw error;
     }
 };
 const downloadAndExtract = async (output, manifest, channel, config) => {
-    const { version, gz, sha256gz } = manifest;
-    const gzUrl = gz ?? config.s3Url(config.s3Key('versioned', {
-        version,
-        channel,
-        bin: config.bin,
-        platform: determinePlatform(config),
-        arch: config.arch,
-        ext: 'gz',
-    }));
-    const { response: stream } = await http_call_1.default.stream(gzUrl);
+    const { gz, sha256gz, version } = manifest;
+    const gzUrl = gz ??
+        config.s3Url(config.s3Key('versioned', {
+            arch: config.arch,
+            bin: config.bin,
+            channel,
+            ext: 'gz',
+            platform: determinePlatform(config),
+            version,
+        }));
+    const { response: stream } = await HTTP.stream(gzUrl);
     stream.pause();
-    const baseDir = manifest.baseDir ?? config.s3Key('baseDir', {
-        version,
-        channel,
-        bin: config.bin,
-        platform: determinePlatform(config),
-        arch: config.arch,
-    });
-    const extraction = (0, tar_1.extract)(stream, baseDir, output, sha256gz);
-    if (core_1.ux.action.type === 'spinner') {
+    const baseDir = manifest.baseDir ??
+        config.s3Key('baseDir', {
+            arch: config.arch,
+            bin: config.bin,
+            channel,
+            platform: determinePlatform(config),
+            version,
+        });
+    const extraction = Extractor.extract(stream, baseDir, output, sha256gz);
+    if (ux.action.type === 'spinner') {
         const total = Number.parseInt(stream.headers['content-length'], 10);
         let current = 0;
-        const updateStatus = (0, lodash_throttle_1.default)((newStatus) => {
-            core_1.ux.action.status = newStatus;
+        const updateStatus = throttle((newStatus) => {
+            ux.action.status = newStatus;
         }, 250, { leading: true, trailing: false });
-        stream.on('data', data => {
+        stream.on('data', (data) => {
             current += data.length;
             updateStatus(`${filesize(current)}/${filesize(total)}`);
         });
@@ -332,13 +330,14 @@ const downloadAndExtract = async (output, manifest, channel, config) => {
     stream.resume();
     await extraction;
 };
-const determineChannel = async ({ version, config }) => {
-    const channelPath = path.join(config.dataDir, 'channel');
-    const channel = (0, node_fs_1.existsSync)(channelPath) ? (await (0, promises_1.readFile)(channelPath, 'utf8')).trim() : 'stable';
+const determineChannel = async ({ config, version }) => {
+    const channelPath = join(config.dataDir, 'channel');
+    // eslint-disable-next-line unicorn/no-await-expression-member
+    const channel = existsSync(channelPath) ? (await readFile(channelPath, 'utf8')).trim() : 'stable';
     try {
-        const { body } = await http_call_1.default.get(`${config.npmRegistry ?? 'https://registry.npmjs.org'}/${config.pjson.name}`);
+        const { body } = await HTTP.get(`${config.npmRegistry ?? 'https://registry.npmjs.org'}/${config.pjson.name}`);
         const tags = body['dist-tags'];
-        const tag = Object.keys(tags).find(v => tags[v] === version) ?? channel;
+        const tag = Object.keys(tags).find((v) => tags[v] === version) ?? channel;
         // convert from npm style tag defaults to OCLIF style
         if (tag === 'latest')
             return 'stable';
@@ -352,22 +351,12 @@ const determineChannel = async ({ version, config }) => {
 };
 const determineCurrentVersion = async (clientBin, version) => {
     try {
-        const currentVersion = await (0, promises_1.readFile)(clientBin, 'utf8');
+        const currentVersion = await readFile(clientBin, 'utf8');
         const matches = currentVersion.match(/\.\.[/\\|](.+)[/\\|]bin/);
         return matches ? matches[1] : version;
     }
     catch (error) {
-        core_1.ux.debug(error);
+        ux.warn(error);
     }
     return version;
 };
-const logChop = async (errlogPath) => {
-    try {
-        core_1.ux.debug('log chop');
-        const logChopper = require('log-chopper').default;
-        await logChopper.chop(errlogPath);
-    }
-    catch (error) {
-        core_1.ux.debug(error.message);
-    }
-};

package/{lib → dist}/util.d.ts

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

package/dist/util.js

@@ -0,0 +1,22 @@
+import { readdir, stat, utimes, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+export async function touch(p) {
+    try {
+        await utimes(p, new Date(), new Date());
+    }
+    catch {
+        await writeFile(p, '');
+    }
+}
+export async function ls(dir) {
+    const files = await readdir(dir);
+    const paths = files.map((f) => join(dir, f));
+    return Promise.all(paths.map((path) => stat(path).then((s) => ({ path, stat: s }))));
+}
+export function wait(ms, unref = false) {
+    return new Promise((resolve) => {
+        const t = setTimeout(() => resolve(), ms);
+        if (unref)
+            t.unref();
+    });
+}