RushVersionSelector.ts

// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.
// See LICENSE in the project root for license information.

import * as path from 'node:path';

import * as semver from 'semver';

import { LockFile, Import } from '@rushstack/node-core-library';
import { REPORTER_PROTOCOL_VERSION, type ReporterPrivacyClassification } from '@rushstack/rush-reporter';
import { Utilities } from '@microsoft/rush-lib/lib/utilities/Utilities';
import { _FlagFile, _RushGlobalFolder } from '@microsoft/rush-lib';

import { RushCommandSelector } from './RushCommandSelector';
import type { IRushFrontendLaunchOptions } from './IRushFrontendLaunchOptions';
import type { MinimalRushConfiguration } from './MinimalRushConfiguration';

const MAX_INSTALL_ATTEMPTS: number = 3;

export class RushVersionSelector {
  #rushGlobalFolder: _RushGlobalFolder;
  #currentPackageVersion: string;

  public constructor(currentPackageVersion: string) {
    this.#rushGlobalFolder = new _RushGlobalFolder();
    this.#currentPackageVersion = currentPackageVersion;
  }

  public async ensureRushVersionInstalledAsync(
    version: string,
    configuration: MinimalRushConfiguration | undefined,
    executeOptions: IRushFrontendLaunchOptions
  ): Promise<void> {
    const isLegacyRushVersion: boolean = semver.lt(version, '4.0.0');
    const expectedRushPath: string = path.join(this.#rushGlobalFolder.nodeSpecificPath, `rush-${version}`);

    const installMarker: _FlagFile = new _FlagFile(expectedRushPath, 'last-install', {
      node: process.versions.node
    });

    let installIsValid: boolean = await installMarker.isValidAsync();
    if (!installIsValid) {
      // Need to install Rush
      this.#reportStartupMessage(
        executeOptions,
        `Rush version ${version} is not currently installed. Installing...`
      );

      const resourceName: string = `rush-${version}`;

      this.#reportStartupMessage(executeOptions, `Trying to acquire lock for ${resourceName}`);

      const lock: LockFile = await LockFile.acquireAsync(expectedRushPath, resourceName);
      installIsValid = await installMarker.isValidAsync();
      if (installIsValid) {
        this.#reportStartupMessage(executeOptions, 'Another process performed the installation.');
      } else {
        await Utilities.installPackageInDirectoryAsync({
          directory: expectedRushPath,
          packageName: isLegacyRushVersion ? '@microsoft/rush' : '@microsoft/rush-lib',
          version: version,
          tempPackageTitle: 'rush-local-install',
          maxInstallAttempts: MAX_INSTALL_ATTEMPTS,
          // This is using a local configuration to install a package in a shared global location.
          // Generally that's a bad practice, but in this case if we can successfully install
          // the package at all, we can reasonably assume it's good for all the repositories.
          // In particular, we'll assume that two different NPM registries cannot have two
          // different implementations of the same version of the same package.
          // This was needed for: https://github.com/microsoft/rushstack/issues/691
          commonRushConfigFolder: configuration ? configuration.commonRushConfigFolder : undefined,
          suppressOutput: true,
          // Filter out npm-incompatible properties (e.g. pnpm-specific settings) from .npmrc
          // since this installation always uses npm regardless of the repo's package manager.
          filterNpmIncompatibleProperties: true
        });

        this.#reportStartupMessage(
          executeOptions,
          `Successfully installed Rush version ${version} in ${expectedRushPath}.`,
          'local-sensitive'
        );

        // If we've made it here without exception, write the flag file
        await installMarker.createAsync();

        lock.release();
      }
    }

    if (semver.lt(version, '3.0.20')) {
      // In old versions, requiring the entry point invoked the command-line parser immediately,
      // so fail if "rushx" or "rush-pnpm" was used
      RushCommandSelector.failIfNotInvokedAsRush(version);
      require(path.join(expectedRushPath, 'node_modules', '@microsoft', 'rush', 'lib', 'rush'));
    } else if (semver.lt(version, '4.0.0')) {
      // In old versions, requiring the entry point invoked the command-line parser immediately,
      // so fail if "rushx" or "rush-pnpm" was used
      RushCommandSelector.failIfNotInvokedAsRush(version);
      require(path.join(expectedRushPath, 'node_modules', '@microsoft', 'rush', 'lib', 'start'));
    } else {
      // Explicitly resolve the entry point for rush-lib, rather than using a simple require, because
      // newer versions of rush-lib use the package.json `exports` field, which maps
      // `lib/index` to `lib-commonjs/index.js`
      const rushLibEntrypoint: string = await Import.resolveModuleAsync({
        modulePath: '@microsoft/rush-lib/lib/index',
        baseFolderPath: expectedRushPath
      });
      const rushCliEntrypoint: typeof import('@microsoft/rush-lib') = require(rushLibEntrypoint);
      // For newer rush-lib, RushCommandSelector can test whether "rushx" is supported or not
      RushCommandSelector.execute(this.#currentPackageVersion, rushCliEntrypoint, executeOptions);
    }
  }

  #reportStartupMessage(
    options: IRushFrontendLaunchOptions,
    text: string,
    privacy: ReporterPrivacyClassification = 'public'
  ): void {
    if (options.reporterEnabled) {
      options.reporter.eventSink.emit({
        protocolVersion: REPORTER_PROTOCOL_VERSION,
        sessionId: options.reporter.sessionId,
        source: { packageName: '@microsoft/rush', packageVersion: this.#currentPackageVersion },
        privacy,
        type: 'activityChanged',
        payload: { kind: 'version-selection', text }
      });
    } else {
      console.log(text);
    }
  }
}