Merge branch 'main' of https://github.com/nodejs/corepack

nodejs · Jan 30, 2024 · d94fe5a · d94fe5a
2 parents 86f53e3 + a56c13b
commit d94fe5a
Show file tree

Hide file tree

Showing 10 changed files with 188 additions and 46 deletions.
diff --git a/README.md b/README.md
@@ -95,15 +95,15 @@ use in the archive).
 ## Known Good Releases
 
 When running Corepack within projects that don't list a supported package
-manager, it will default to a set of Known Good Releases. In a way, you can
-compare this to Node.js, where each version ships with a specific version of
-npm.
+manager, it will default to a set of Known Good Releases.
 
 If there is no Known Good Release for the requested package manager, Corepack
 looks up the npm registry for the latest available version and cache it for
 future use.
 
 The Known Good Releases can be updated system-wide using `corepack install -g`.
+When Corepack downloads a new version of a given package manager on the same
+major line as the Known Good Release, it auto-updates it by default.
 
 ## Offline Workflow
 
@@ -232,7 +232,16 @@ same major line. Should you need to upgrade to a new major, use an explicit
 
 - `COREPACK_DEFAULT_TO_LATEST` can be set to `0` in order to instruct Corepack
   not to lookup on the remote registry for the latest version of the selected
-  package manager.
+  package manager, and to not update the Last Known Good version when it
+  downloads a new version of the same major line.
+
+- `COREPACK_ENABLE_DOWNLOAD_PROMPT` can be set to `0` to
+  prevent Corepack showing the URL when it needs to download software, or can be
+  set to `1` to have the URL shown. By default, when Corepack is called
+  explicitly (e.g. `corepack pnpm …`), it is set to `0`; when Corepack is called
+  implicitely (e.g. `pnpm …`), it is set to `1`.
+  When standard input is a TTY and no CI environment is detected, Corepack will
+  ask for user input before starting the download.
 
 - `COREPACK_ENABLE_URL_VERSION_FOR_KNOWN_PM` can be set to `1` to allow use of
   custom URLs to load a package manager known by Corepack (`yarn`, `npm`, and

diff --git a/mkshims.ts b/mkshims.ts
@@ -21,6 +21,7 @@ async function main() {
   const corepackPath = path.join(distDir, `corepack.js`);
   fs.writeFileSync(corepackPath, [
     `#!/usr/bin/env node`,
+    `process.env.COREPACK_ENABLE_DOWNLOAD_PROMPT??='0';`,
     `require('./lib/corepack.cjs').runMain(process.argv.slice(2));`,
   ].join(`\n`));
   fs.chmodSync(corepackPath, 0o755);
@@ -32,6 +33,7 @@ async function main() {
       const entryPath = path.join(distDir, `${binaryName}.js`);
       const entryScript = [
         `#!/usr/bin/env node`,
+        `process.env.COREPACK_ENABLE_DOWNLOAD_PROMPT??='1'`,
         `require('./lib/corepack.cjs').runMain(['${binaryName}', ...process.argv.slice(2)]);`,
       ].join(`\n`);
 

diff --git a/sources/Engine.ts b/sources/Engine.ts
@@ -1,4 +1,5 @@
 import {UsageError}                                           from 'clipanion';
+import type {FileHandle}                                      from 'fs/promises';
 import fs                                                     from 'fs';
 import path                                                   from 'path';
 import process                                                from 'process';
@@ -7,14 +8,58 @@ import semver                                                 from 'semver';
 import defaultConfig                                          from '../config.json';
 
 import * as corepackUtils                                     from './corepackUtils';
+import * as debugUtils                                        from './debugUtils';
 import * as folderUtils                                       from './folderUtils';
+import type {NodeError}                                       from './nodeUtils';
 import * as semverUtils                                       from './semverUtils';
 import {Config, Descriptor, Locator, PackageManagerSpec}      from './types';
 import {SupportedPackageManagers, SupportedPackageManagerSet} from './types';
 import {isSupportedPackageManager}                            from './types';
 
 export type PreparedPackageManagerInfo = Awaited<ReturnType<Engine[`ensurePackageManager`]>>;
 
+export function getLastKnownGoodFile(flag = `r`) {
+  return fs.promises.open(path.join(folderUtils.getInstallFolder(), `lastKnownGood.json`), flag);
+}
+
+export async function getJSONFileContent(fh: FileHandle) {
+  let lastKnownGood: unknown;
+  try {
+    lastKnownGood = JSON.parse(await fh.readFile(`utf8`));
+  } catch {
+    // Ignore errors; too bad
+    return undefined;
+  }
+
+  return lastKnownGood;
+}
+
+async function overwriteJSONFileContent(fh: FileHandle, content: unknown) {
+  await fh.truncate(0);
+  await fh.write(`${JSON.stringify(content, null, 2)}\n`, 0);
+}
+
+export function getLastKnownGoodFromFileContent(lastKnownGood: unknown, packageManager: string) {
+  if (typeof lastKnownGood === `object` && lastKnownGood !== null &&
+    Object.hasOwn(lastKnownGood, packageManager)) {
+    const override = (lastKnownGood as any)[packageManager];
+    if (typeof override === `string`) {
+      return override;
+    }
+  }
+  return undefined;
+}
+
+export async function activatePackageManagerFromFileHandle(lastKnownGoodFile: FileHandle, lastKnownGood: unknown, locator: Locator) {
+  if (typeof lastKnownGood !== `object` || lastKnownGood === null)
+    lastKnownGood = {};
+
+  (lastKnownGood as Record<string, string>)[locator.name] = locator.reference;
+
+  debugUtils.log(`Setting ${locator.name}@${locator.reference} as Last Known Good version`);
+  await overwriteJSONFileContent(lastKnownGoodFile, lastKnownGood);
+}
+
 export class Engine {
   constructor(public config: Config = defaultConfig as Config) {
   }
@@ -94,51 +139,52 @@ export class Engine {
     if (typeof definition === `undefined`)
       throw new UsageError(`This package manager (${packageManager}) isn't supported by this corepack build`);
 
-    let lastKnownGood: unknown;
-    try {
-      lastKnownGood = JSON.parse(await fs.promises.readFile(this.getLastKnownGoodFile(), `utf8`));
-    } catch {
-      // Ignore errors; too bad
-    }
-
-    if (typeof lastKnownGood === `object` && lastKnownGood !== null &&
-        Object.hasOwn(lastKnownGood, packageManager)) {
-      const override = (lastKnownGood as any)[packageManager];
-      if (typeof override === `string`) {
-        return override;
+    let emptyFile = false;
+    const lastKnownGoodFile = await getLastKnownGoodFile(`r+`).catch(err => {
+      if ((err as NodeError)?.code === `ENOENT`) {
+        emptyFile = true;
+        return getLastKnownGoodFile(`w`);
       }
-    }
 
-    if (process.env.COREPACK_DEFAULT_TO_LATEST === `0`)
-      return definition.default;
+      throw err;
+    });
+    try {
+      const lastKnownGood = emptyFile || await getJSONFileContent(lastKnownGoodFile);
+      const lastKnownGoodForThisPackageManager = getLastKnownGoodFromFileContent(lastKnownGood, packageManager);
+      if (lastKnownGoodForThisPackageManager)
+        return lastKnownGoodForThisPackageManager;
 
-    const reference = await corepackUtils.fetchLatestStableVersion(definition.fetchLatestFrom);
+      if (process.env.COREPACK_DEFAULT_TO_LATEST === `0`)
+        return definition.default;
 
-    await this.activatePackageManager({
-      name: packageManager,
-      reference,
-    });
+      const reference = await corepackUtils.fetchLatestStableVersion(definition.fetchLatestFrom);
+
+      await activatePackageManagerFromFileHandle(lastKnownGoodFile, lastKnownGood, {
+        name: packageManager,
+        reference,
+      });
 
-    return reference;
+      return reference;
+    } finally {
+      await lastKnownGoodFile.close();
+    }
   }
 
   async activatePackageManager(locator: Locator) {
-    const lastKnownGoodFile = this.getLastKnownGoodFile();
+    let emptyFile = false;
+    const lastKnownGoodFile = await getLastKnownGoodFile(`r+`).catch(err => {
+      if ((err as NodeError)?.code === `ENOENT`) {
+        emptyFile = true;
+        return getLastKnownGoodFile(`w`);
+      }
 
-    let lastKnownGood;
+      throw err;
+    });
     try {
-      lastKnownGood = JSON.parse(await fs.promises.readFile(lastKnownGoodFile, `utf8`));
-    } catch {
-      // Ignore errors; too bad
+      await activatePackageManagerFromFileHandle(lastKnownGoodFile, emptyFile || await getJSONFileContent(lastKnownGoodFile), locator);
+    } finally {
+      await lastKnownGoodFile.close();
     }
-
-    if (typeof lastKnownGood !== `object` || lastKnownGood === null)
-      lastKnownGood = {};
-
-    lastKnownGood[locator.name] = locator.reference;
-
-    await fs.promises.mkdir(path.dirname(lastKnownGoodFile), {recursive: true});
-    await fs.promises.writeFile(lastKnownGoodFile, `${JSON.stringify(lastKnownGood, null, 2)}\n`);
   }
 
   async ensurePackageManager(locator: Locator) {
@@ -221,8 +267,4 @@ export class Engine {
 
     return {name: finalDescriptor.name, reference: highestVersion[0]};
   }
-
-  private getLastKnownGoodFile() {
-    return path.join(folderUtils.getInstallFolder(), `lastKnownGood.json`);
-  }
 }
diff --git a/sources/corepackUtils.ts b/sources/corepackUtils.ts
@@ -1,11 +1,13 @@
 import {createHash}                                            from 'crypto';
 import {once}                                                  from 'events';
+import {FileHandle}                                            from 'fs/promises';
 import fs                                                      from 'fs';
 import type {Dir}                                              from 'fs';
 import Module                                                  from 'module';
 import path                                                    from 'path';
 import semver                                                  from 'semver';
 
+import * as engine                                             from './Engine';
 import * as debugUtils                                         from './debugUtils';
 import * as folderUtils                                        from './folderUtils';
 import * as fsUtils                                            from './fsUtils';
@@ -124,7 +126,6 @@ function parseURLReference(locator: URLLocator) {
 }
 
 export async function installVersion(installTarget: string, locator: Locator, {spec}: {spec: PackageManagerSpec}) {
-  const {default: tar} = await import(`tar`);
   const locatorIsASupportedPackageManager = isSupportedPackageManagerLocator(locator);
   const {version, build} = locatorIsASupportedPackageManager ? semver.parse(locator.reference)! : parseURLReference(locator);
 
@@ -182,6 +183,7 @@ export async function installVersion(installTarget: string, locator: Locator, {s
 
   let sendTo: any;
   if (ext === `.tgz`) {
+    const {default: tar} = await import(`tar`);
     sendTo = tar.x({strip: 1, cwd: tmpFolder});
   } else if (ext === `.js`) {
     outputFile = path.join(tmpFolder, path.posix.basename(parsedUrl.pathname));
@@ -237,6 +239,29 @@ export async function installVersion(installTarget: string, locator: Locator, {s
     }
   }
 
+  if (process.env.COREPACK_DEFAULT_TO_LATEST !== `0`) {
+    let lastKnownGoodFile: FileHandle;
+    try {
+      lastKnownGoodFile = await engine.getLastKnownGoodFile(`r+`);
+      const lastKnownGood = await engine.getJSONFileContent(lastKnownGoodFile);
+      const defaultVersion = engine.getLastKnownGoodFromFileContent(lastKnownGood, locator.name);
+      if (defaultVersion) {
+        const currentDefault = semver.parse(defaultVersion)!;
+        if (currentDefault.major === locatorReference.major && semver.lt(currentDefault, locatorReference)) {
+          await engine.activatePackageManagerFromFileHandle(lastKnownGoodFile, lastKnownGood, locator);
+        }
+      }
+    } catch (err) {
+      // ENOENT would mean there are no lastKnownGoodFile, in which case we can ignore.
+      if ((err as nodeUtils.NodeError)?.code !== `ENOENT`) {
+        throw err;
+      }
+    } finally {
+      // @ts-expect-error used before assigned
+      await lastKnownGoodFile?.close();
+    }
+  }
+
   debugUtils.log(`Install finished`);
 
   return {

diff --git a/sources/httpUtils.ts b/sources/httpUtils.ts
@@ -1,6 +1,8 @@
-import {UsageError}                     from 'clipanion';
-import {RequestOptions}                 from 'https';
-import {IncomingMessage, ClientRequest} from 'http';
+import {UsageError}                          from 'clipanion';
+import {once}                                from 'events';
+import type {RequestOptions}                 from 'https';
+import type {IncomingMessage, ClientRequest} from 'http';
+import {stderr, stdin}                       from 'process';
 
 export async function fetchUrlStream(url: string, options: RequestOptions = {}) {
   if (process.env.COREPACK_ENABLE_NETWORK === `0`)
@@ -12,6 +14,22 @@ export async function fetchUrlStream(url: string, options: RequestOptions = {})
 
   const proxyAgent = new ProxyAgent();
 
+  if (process.env.COREPACK_ENABLE_DOWNLOAD_PROMPT === `1`) {
+    console.error(`Corepack is about to download ${url}.`);
+    if (stdin.isTTY && !process.env.CI) {
+      stderr.write(`\nDo you want to continue? [Y/n] `);
+      stdin.resume();
+      const chars = await once(stdin, `data`);
+      stdin.pause();
+      if (
+        chars[0][0] === 0x6e || // n
+        chars[0][0] === 0x4e // N
+      ) {
+        throw new UsageError(`Aborted by the user`);
+      }
+    }
+  }
+
   return new Promise<IncomingMessage>((resolve, reject) => {
     const createRequest = (url: string) => {
       const request: ClientRequest = https.get(url, {...options, agent: proxyAgent}, response => {

diff --git a/tests/main.test.ts b/tests/main.test.ts
@@ -160,6 +160,52 @@ for (const [name, version, expectedVersion = version.split(`+`, 1)[0]] of tested
   });
 }
 
+it(`should update the Known Good Release only when the major matches`, async () => {
+  await xfs.writeJsonPromise(ppath.join(corepackHome, `lastKnownGood.json`), {
+    yarn: `1.0.0`,
+  });
+
+  process.env.COREPACK_DEFAULT_TO_LATEST = `1`;
+
+  await xfs.mktempPromise(async cwd => {
+    await xfs.writeJsonPromise(ppath.join(cwd, `package.json` as Filename), {
+      packageManager: `[email protected]+sha224.0d6eecaf4d82ec12566fdd97143794d0f0c317e0d652bd4d1b305430`,
+    });
+
+    await expect(runCli(cwd, [`yarn`, `--version`])).resolves.toMatchObject({
+      exitCode: 0,
+      stderr: ``,
+      stdout: `1.22.4\n`,
+    });
+
+    await xfs.removePromise(ppath.join(cwd, `package.json` as Filename));
+
+    await expect(runCli(cwd, [`yarn`, `--version`])).resolves.toMatchObject({
+      exitCode: 0,
+      stderr: ``,
+      stdout: `1.22.4\n`,
+    });
+
+    await xfs.writeJsonPromise(ppath.join(cwd, `package.json` as Filename), {
+      packageManager: `[email protected]`,
+    });
+
+    await expect(runCli(cwd, [`yarn`, `--version`])).resolves.toMatchObject({
+      exitCode: 0,
+      stderr: ``,
+      stdout: `2.2.2\n`,
+    });
+
+    await xfs.removePromise(ppath.join(cwd, `package.json` as Filename));
+
+    await expect(runCli(cwd, [`yarn`, `--version`])).resolves.toMatchObject({
+      exitCode: 0,
+      stderr: ``,
+      stdout: `1.22.4\n`,
+    });
+  });
+});
+
 it(`should ignore the packageManager field when found within a node_modules vendor`, async () => {
   await xfs.mktempPromise(async cwd => {
     await xfs.mkdirPromise(ppath.join(cwd, `node_modules/foo` as PortablePath), {recursive: true});

diff --git a/tests/nock/_ssVB5fpNumqL8RMl4TqHw-1.dat b/tests/nock/_ssVB5fpNumqL8RMl4TqHw-1.dat
diff --git a/tests/nock/_ssVB5fpNumqL8RMl4TqHw-2.dat b/tests/nock/_ssVB5fpNumqL8RMl4TqHw-2.dat
diff --git a/tests/nock/_ssVB5fpNumqL8RMl4TqHw-3.dat b/tests/nock/_ssVB5fpNumqL8RMl4TqHw-3.dat
diff --git a/tests/nock/_ssVB5fpNumqL8RMl4TqHw-4.dat b/tests/nock/_ssVB5fpNumqL8RMl4TqHw-4.dat