setup-node/src/main.ts

import * as core from '@actions/core';

import os from 'os';
import fs from 'fs';
import {fileURLToPath} from 'url';

import * as auth from './authutil.js';
import * as path from 'path';
import {restoreCache} from './cache-restore.js';
import {isCacheFeatureAvailable} from './cache-utils.js';
import {getNodejsDistribution} from './distributions/installer-factory.js';
import {getNodeVersionFromFile, printEnvDetailsAndSetOutput} from './util.js';
import {State} from './constants.js';

export async function run() {
  try {
    //
    // Version is optional.  If supplied, install / use from the tool cache
    // If not supplied then task is still used to setup proxy, auth, etc...
    //
    const version = resolveVersionInput();

    let arch = core.getInput('architecture');
    const cache = core.getInput('cache');
    const packagemanagercache =
      (core.getInput('package-manager-cache') || 'true').toUpperCase() ===
      'TRUE';

    // if architecture supplied but node-version is not
    // if we don't throw a warning, the already installed x64 node will be used which is not probably what user meant.
    if (arch && !version) {
      core.warning(
        '`architecture` is provided but `node-version` is missing. In this configuration, the version/architecture of Node will not be changed. To fix this, provide `architecture` in combination with `node-version`'
      );
    }

    if (!arch) {
      arch = os.arch();
    }

    if (version) {
      const token = core.getInput('token');
      const auth = !token ? undefined : `token ${token}`;
      const mirror = core.getInput('mirror');
      const mirrorToken = core.getInput('mirror-token');
      const stable =
        (core.getInput('stable') || 'true').toUpperCase() === 'TRUE';
      const checkLatest =
        (core.getInput('check-latest') || 'false').toUpperCase() === 'TRUE';
      const nodejsInfo = {
        versionSpec: version,
        checkLatest,
        auth,
        stable,
        arch,
        mirror,
        mirrorToken
      };
      const nodeDistribution = getNodejsDistribution(nodejsInfo);
      await nodeDistribution.setupNodeJs();
    }

    await printEnvDetailsAndSetOutput();

    const registryUrl: string = core.getInput('registry-url');
    if (registryUrl) {
      auth.configAuthentication(registryUrl);
    }

    const cacheDependencyPath = core.getInput('cache-dependency-path');

    if (isCacheFeatureAvailable()) {
      // if the cache input is provided, use it for caching.
      if (cache) {
        core.saveState(State.CachePackageManager, cache);
        await restoreCache(cache, cacheDependencyPath);
        // package manager npm is detected from package.json, enable auto-caching for npm.
      } else if (packagemanagercache) {
        const resolvedPackageManager = getNameFromPackageManagerField();
        if (resolvedPackageManager) {
          core.info(
            "Detected npm as the package manager from package.json's packageManager field. " +
              'Auto caching has been enabled for npm. If you want to disable it, set package-manager-cache input to false'
          );
          core.saveState(State.CachePackageManager, resolvedPackageManager);
          await restoreCache(resolvedPackageManager, cacheDependencyPath);
        }
      }
    }

    const matchersPath = path.join(
      path.dirname(fileURLToPath(import.meta.url)),
      '../..',
      '.github'
    );
    core.info(`##[add-matcher]${path.join(matchersPath, 'tsc.json')}`);
    core.info(
      `##[add-matcher]${path.join(matchersPath, 'eslint-stylish.json')}`
    );
    core.info(
      `##[add-matcher]${path.join(matchersPath, 'eslint-compact.json')}`
    );
  } catch (err) {
    core.setFailed((err as Error).message);
  }
}

function resolveVersionInput(): string {
  let version = core.getInput('node-version');
  const versionFileInput = core.getInput('node-version-file');

  if (version && versionFileInput) {
    core.warning(
      'Both node-version and node-version-file inputs are specified, only node-version will be used'
    );
  }

  if (version) {
    return version;
  }

  if (versionFileInput) {
    // `path.resolve` (unlike `path.join`) keeps an already-absolute input as-is,
    // so a composite action can pass `${{ github.action_path }}/.nvmrc`.
    const versionFilePath = path.resolve(
      process.env.GITHUB_WORKSPACE!,
      versionFileInput
    );

    const parsedVersion = getNodeVersionFromFile(versionFilePath);

    if (parsedVersion) {
      version = parsedVersion;
    } else {
      core.warning(
        `Could not determine node version from ${versionFilePath}. Falling back`
      );
    }

    core.info(`Resolved ${versionFileInput} as ${version}`);
  }

  return version;
}

export function getNameFromPackageManagerField(): string | undefined {
  const npmRegex = /^(\^)?npm(@.*)?$/; // matches "npm", "npm@...", "^npm@..."
  try {
    const packageJson = JSON.parse(
      fs.readFileSync(
        path.join(process.env.GITHUB_WORKSPACE!, 'package.json'),
        'utf-8'
      )
    );

    // Check devEngines.packageManager first (object or array)
    const devPM = packageJson?.devEngines?.packageManager;
    const devPMArray = devPM ? (Array.isArray(devPM) ? devPM : [devPM]) : [];
    for (const obj of devPMArray) {
      if (typeof obj?.name === 'string' && npmRegex.test(obj.name)) {
        return 'npm';
      }
    }

    // Check top-level packageManager
    const topLevelPM = packageJson?.packageManager;
    if (typeof topLevelPM === 'string' && npmRegex.test(topLevelPM)) {
      return 'npm';
    }

    return undefined;
  } catch {
    return undefined;
  }
}