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

package/README.md

@@ -1,22 +1,25 @@
-@oclif/plugin-update
-====================
+# @oclif/plugin-update
 
 [![Version](https://img.shields.io/npm/v/@oclif/plugin-update.svg)](https://npmjs.org/package/@oclif/plugin-update)
-[![CircleCI](https://circleci.com/gh/oclif/plugin-update/tree/main.svg?style=shield)](https://circleci.com/gh/oclif/plugin-update/tree/main)
-[![Appveyor CI](https://ci.appveyor.com/api/projects/status/github/oclif/plugin-update?branch=main&svg=true)](https://ci.appveyor.com/project/oclif/plugin-update/branch/main)
 [![Downloads/week](https://img.shields.io/npm/dw/@oclif/plugin-update.svg)](https://npmjs.org/package/@oclif/plugin-update)
 [![License](https://img.shields.io/npm/l/@oclif/plugin-update.svg)](https://github.com/oclif/plugin-update/blob/main/package.json)
 
 <!-- toc -->
-* [Usage](#usage)
-* [Commands](#commands)
+
+- [@oclif/plugin-update](#oclifplugin-update)
+- [Usage](#usage)
+- [Commands](#commands)
 <!-- tocstop -->
+
 # Usage
+
 See https://oclif.io/docs/releasing.html#autoupdater
 
 # Commands
+
 <!-- commands -->
-* [`oclif-example update [CHANNEL]`](#oclif-example-update-channel)
+
+- [`oclif-example update [CHANNEL]`](#oclif-example-update-channel)
 
 ## `oclif-example update [CHANNEL]`
 
@@ -24,10 +27,10 @@ update the oclif-example CLI
 
 ```
 USAGE
-  $ oclif-example update [CHANNEL] [-a] [-v <value> | -i] [--force]
+  $ oclif-example update [CHANNEL] [-a] [--force] [-i | -v <value>]
 
 FLAGS
-  -a, --available        Install a specific version.
+  -a, --available        See available versions.
   -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.
@@ -53,5 +56,6 @@ EXAMPLES
     $ oclif-example update --available
 ```
 
-_See code: [src/commands/update.ts](https://github.com/oclif/plugin-update/blob/v3.0.0/src/commands/update.ts)_
+_See code: [src/commands/update.ts](https://github.com/oclif/plugin-update/blob/4.1.1/src/commands/update.ts)_
+
 <!-- commandsstop -->

package/dist/commands/update.d.ts

@@ -0,0 +1,20 @@
+import { Command } from '@oclif/core';
+export default class UpdateCommand extends Command {
+    static args: {
+        channel: import("@oclif/core/lib/interfaces/parser.js").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: {
+        command: string;
+        description: string;
+    }[];
+    static flags: {
+        autoupdate: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        available: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        force: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        interactive: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        version: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    };
+    run(): Promise<void>;
+    private promptForVersion;
+}

package/dist/commands/update.js

@@ -0,0 +1,83 @@
+import { Args, Command, Flags, ux } from '@oclif/core';
+import inquirer from 'inquirer';
+import { basename } from 'node:path';
+import { sort } from 'semver';
+import { Updater } from '../update.js';
+export default class UpdateCommand extends Command {
+    static args = {
+        channel: Args.string({ optional: true }),
+    };
+    static description = 'update the <%= config.bin %> CLI';
+    static examples = [
+        {
+            command: '<%= config.bin %> <%= command.id %> stable',
+            description: 'Update to the stable channel:',
+        },
+        {
+            command: '<%= config.bin %> <%= command.id %> --version 1.0.0',
+            description: 'Update to a specific version:',
+        },
+        {
+            command: '<%= config.bin %> <%= command.id %> --interactive',
+            description: 'Interactively select version:',
+        },
+        {
+            command: '<%= config.bin %> <%= command.id %> --available',
+            description: 'See available versions:',
+        },
+    ];
+    static flags = {
+        autoupdate: Flags.boolean({ hidden: true }),
+        available: Flags.boolean({
+            char: 'a',
+            description: 'See available versions.',
+        }),
+        force: Flags.boolean({
+            description: 'Force a re-download of the requested version.',
+        }),
+        interactive: Flags.boolean({
+            char: 'i',
+            description: 'Interactively select version to install. This is ignored if a channel is provided.',
+            exclusive: ['version'],
+        }),
+        version: Flags.string({
+            char: 'v',
+            description: 'Install a specific version.',
+            exclusive: ['interactive'],
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(UpdateCommand);
+        const updater = new Updater(this.config);
+        if (flags.available) {
+            const index = await updater.fetchVersionIndex();
+            const allVersions = sort(Object.keys(index)).reverse();
+            const localVersions = await updater.findLocalVersions();
+            const table = allVersions.map((version) => {
+                const location = localVersions.find((l) => basename(l).startsWith(version)) || index[version];
+                return { location, version };
+            });
+            ux.table(table, { location: {}, version: {} });
+            return;
+        }
+        if (args.channel && flags.version) {
+            this.error('You cannot specify both a version and a channel.');
+        }
+        return updater.runUpdate({
+            autoUpdate: flags.autoupdate,
+            channel: args.channel,
+            force: flags.force,
+            version: flags.interactive ? await this.promptForVersion(updater) : flags.version,
+        });
+    }
+    async promptForVersion(updater) {
+        const choices = sort(Object.keys(await updater.fetchVersionIndex())).reverse();
+        const { version } = await inquirer.prompt({
+            choices: [...choices, new inquirer.Separator()],
+            message: 'Select a version to update to',
+            name: 'version',
+            type: 'list',
+        });
+        return version;
+    }
+}

package/dist/hooks/init.js

@@ -0,0 +1,67 @@
+import { spawn } from 'cross-spawn';
+import makeDebug from 'debug';
+import { existsSync } from 'node:fs';
+import { open, stat, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { touch } from '../util.js';
+const debug = makeDebug('cli:updater');
+function timestamp(msg) {
+    return `[${new Date().toISOString()}] ${msg}`;
+}
+async function mtime(f) {
+    const { mtime } = await stat(f);
+    return mtime;
+}
+export const init = async function (opts) {
+    if (opts.id === 'update')
+        return;
+    if (opts.config.scopedEnvVarTrue('DISABLE_AUTOUPDATE'))
+        return;
+    const { config, error: throwError } = this;
+    const binPath = config.binPath ?? config.bin;
+    const lastrunfile = join(config.cacheDir, 'lastrun');
+    const autoupdatefile = join(config.cacheDir, 'autoupdate');
+    const autoupdatelogfile = join(config.cacheDir, 'autoupdate.log');
+    const clientRoot = config.scopedEnvVar('OCLIF_CLIENT_HOME') ?? join(config.dataDir, 'client');
+    const autoupdateEnv = {
+        ...process.env,
+        [config.scopedEnvVarKey('SKIP_ANALYTICS')]: '1',
+        [config.scopedEnvVarKey('TIMESTAMPS')]: '1',
+    };
+    async function autoupdateNeeded() {
+        try {
+            const m = await mtime(autoupdatefile);
+            let days = 1;
+            if (opts.config.channel === 'stable')
+                days = 14;
+            m.setHours(m.getHours() + days * 24);
+            return m < new Date();
+        }
+        catch (error) {
+            const err = error;
+            if (err.code !== 'ENOENT')
+                throwError(err.stack);
+            debug('autoupdate ENOENT');
+            return true;
+        }
+    }
+    await touch(lastrunfile);
+    const clientDir = join(clientRoot, config.version);
+    if (existsSync(clientDir))
+        await touch(clientDir);
+    if (!(await autoupdateNeeded()))
+        return;
+    debug('autoupdate running');
+    await writeFile(autoupdatefile, '');
+    debug(`spawning autoupdate on ${binPath}`);
+    const fd = await open(autoupdatelogfile, 'a');
+    await writeFile(fd, timestamp(`starting \`${binPath} update --autoupdate\` from ${process.argv.slice(1, 3).join(' ')}\n`));
+    const stream = fd.createWriteStream();
+    spawn(binPath, ['update', '--autoupdate'], {
+        detached: !config.windows,
+        env: autoupdateEnv,
+        stdio: ['ignore', stream, stream],
+    })
+        .on('error', (e) => process.emitWarning(e))
+        .unref();
+};

package/dist/tar.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="node" resolution-mode="require"/>
+declare function extract(stream: NodeJS.ReadableStream, basename: string, output: string, sha?: string): Promise<void>;
+export declare const Extractor: {
+    extract: typeof extract;
+};
+export {};

package/{lib → dist}/tar.js

@@ -1,43 +1,43 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.extract = void 0;
-const tslib_1 = require("tslib");
-const fs = tslib_1.__importStar(require("node:fs/promises"));
-const node_fs_1 = require("node:fs");
-const path = tslib_1.__importStar(require("path"));
-const util_1 = require("./util");
-const debug = require('debug')('oclif-update');
-const ignore = (_, header) => {
-    switch (header.type) {
+import makeDebug from 'debug';
+import { existsSync } from 'node:fs';
+import { cp, rename, rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import { touch } from './util.js';
+const debug = makeDebug('oclif-update');
+import crypto from 'node:crypto';
+import zlib from 'node:zlib';
+import { extract as tarExtract } from 'tar-fs';
+const ignore = (_name, header) => {
+    switch (header?.type) {
         case 'directory':
-        case 'file':
+        case 'file': {
             if (process.env.OCLIF_DEBUG_UPDATE_FILES)
                 debug(header.name);
             return false;
-        case 'symlink':
+        }
+        case 'symlink': {
             return true;
-        default:
-            throw new Error(header.type);
+        }
+        default: {
+            throw new Error(header?.type);
+        }
     }
 };
 async function extract(stream, basename, output, sha) {
     const getTmp = () => `${output}.partial.${Math.random().toString().split('.')[1].slice(0, 5)}`;
     let tmp = getTmp();
-    if ((0, node_fs_1.existsSync)(tmp))
+    if (existsSync(tmp))
         tmp = getTmp();
     debug(`extracting to ${tmp}`);
     try {
         await new Promise((resolve, reject) => {
-            const zlib = require('zlib');
-            const tar = require('tar-fs');
-            const crypto = require('crypto');
             let shaValidated = false;
             let extracted = false;
             const check = () => shaValidated && extracted && resolve(null);
             if (sha) {
                 const hasher = crypto.createHash('sha256');
                 stream.on('error', reject);
-                stream.on('data', d => hasher.update(d));
+                stream.on('data', (d) => hasher.update(d));
                 stream.on('end', () => {
                     const shasum = hasher.digest('hex');
                     if (sha === shasum) {
@@ -51,7 +51,7 @@ async function extract(stream, basename, output, sha) {
             }
             else
                 shaValidated = true;
-            const extract = tar.extract(tmp, { ignore });
+            const extract = tarExtract(tmp, { ignore });
             extract.on('error', reject);
             extract.on('finish', () => {
                 extracted = true;
@@ -61,28 +61,30 @@ async function extract(stream, basename, output, sha) {
             gunzip.on('error', reject);
             stream.pipe(gunzip).pipe(extract);
         });
-        if ((0, node_fs_1.existsSync)(output)) {
+        if (existsSync(output)) {
             try {
                 const tmp = getTmp();
-                const { move } = await Promise.resolve().then(() => tslib_1.__importStar(require('fs-extra')));
-                await move(output, tmp);
-                await fs.rm(tmp, { recursive: true, force: true }).catch(debug);
+                await cp(output, tmp);
+                await rm(tmp, { force: true, recursive: true }).catch(debug);
             }
             catch (error) {
                 debug(error);
-                await fs.rm(tmp, { recursive: true, force: true }).catch(debug);
+                await rm(tmp, { force: true, recursive: true }).catch(debug);
             }
         }
-        const from = path.join(tmp, basename);
+        const from = join(tmp, basename);
         debug('moving %s to %s', from, output);
-        await fs.rename(from, output);
-        await fs.rm(tmp, { recursive: true, force: true }).catch(debug);
-        await (0, util_1.touch)(output);
+        await rename(from, output);
+        await rm(tmp, { force: true, recursive: true }).catch(debug);
+        await touch(output);
         debug('done extracting');
     }
     catch (error) {
-        await fs.rm(tmp, { recursive: true, force: true }).catch(process.emitWarning);
+        await rm(tmp, { force: true, recursive: true }).catch(process.emitWarning);
         throw error;
     }
 }
-exports.extract = extract;
+// This is done so that we can stub it in tests
+export const Extractor = {
+    extract,
+};

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

@@ -1,27 +1,26 @@
 import { Config } from '@oclif/core';
-export declare namespace Updater {
-    type Options = {
-        autoUpdate: boolean;
-        channel?: string | undefined;
-        version?: string | undefined;
-        force?: boolean;
-    };
-    type VersionIndex = Record<string, string>;
-}
+type Options = {
+    autoUpdate: boolean;
+    channel?: string | undefined;
+    force?: boolean;
+    version?: string | undefined;
+};
+type VersionIndex = Record<string, string>;
 export declare class Updater {
     private config;
-    private readonly clientRoot;
     private readonly clientBin;
+    private readonly clientRoot;
     constructor(config: Config);
-    runUpdate(options: Updater.Options): Promise<void>;
+    fetchVersionIndex(): Promise<VersionIndex>;
     findLocalVersions(): Promise<string[]>;
-    fetchVersionIndex(): Promise<Updater.VersionIndex>;
+    runUpdate(options: Options): Promise<void>;
+    private createBin;
     private fetchVersionManifest;
-    private update;
-    private updateToExistingVersion;
     private findLocalVersion;
+    private refreshConfig;
     private tidy;
     private touch;
-    private refreshConfig;
-    private createBin;
+    private update;
+    private updateToExistingVersion;
 }
+export {};