Merge e5561a4d32 into 802632921f

__tests__/main.test.ts

@@ -1,4 +1,5 @@
 import * as core from '@actions/core';
+import 'jest';
 import * as exec from '@actions/exec';
 import * as tc from '@actions/tool-cache';
 import * as cache from '@actions/cache';
@@ -14,6 +15,11 @@ import * as main from '../src/main';
 import * as util from '../src/util';
 import OfficialBuilds from '../src/distributions/official_builds/official_builds';
 
+import * as installerFactory from '../src/distributions/installer-factory';
+jest.mock('../src/distributions/installer-factory', () => ({
+  getNodejsDistribution: jest.fn()
+}));
+
 describe('main tests', () => {
   let inputs = {} as any;
   let os = {} as any;
@@ -280,4 +286,93 @@ describe('main tests', () => {
       );
     });
   });
+
+  // Create a mock object that satisfies the BaseDistribution interface
+  const createMockNodejsDistribution = () => ({
+    setupNodeJs: jest.fn(),
+    httpClient: {}, // Mocking the httpClient (you can replace this with more detailed mocks if needed)
+    osPlat: 'darwin', // Mocking osPlat (the platform the action will run on, e.g., 'darwin', 'win32', 'linux')
+    nodeInfo: {
+      version: '14.x',
+      arch: 'x64',
+      platform: 'darwin'
+    },
+    getDistributionUrl: jest.fn().mockReturnValue('https://nodejs.org/dist/'), // Example URL
+    install: jest.fn(),
+    validate: jest.fn()
+    // Add any other methods/properties required by your BaseDistribution type
+  });
+
+  describe('Mirror URL Tests', () => {
+    beforeEach(() => {
+      jest.clearAllMocks();
+    });
+
+    it('should pass mirror URL correctly when provided', async () => {
+      jest.spyOn(core, 'getInput').mockImplementation((name: string) => {
+        if (name === 'mirror-url') return 'https://custom-mirror-url.com';
+        if (name === 'node-version') return '14.x';
+        return '';
+      });
+
+      const mockNodejsDistribution = createMockNodejsDistribution();
+      (installerFactory.getNodejsDistribution as jest.Mock).mockReturnValue(
+        mockNodejsDistribution
+      );
+
+      await main.run();
+
+      // Ensure setupNodeJs is called with the correct parameters, including the mirror URL
+      expect(mockNodejsDistribution.setupNodeJs).toHaveBeenCalledWith({
+        versionSpec: '14.x',
+        checkLatest: false,
+        auth: undefined,
+        stable: true,
+        arch: 'x64',
+        mirrorURL: 'https://custom-mirror-url.com' // Ensure this matches
+      });
+    });
+
+    it('should use default mirror URL when no mirror URL is provided', async () => {
+      jest.spyOn(core, 'getInput').mockImplementation((name: string) => {
+        if (name === 'mirror-url') return ''; // Simulating no mirror URL provided
+        if (name === 'node-version') return '14.x';
+        return '';
+      });
+
+      const mockNodejsDistribution = createMockNodejsDistribution();
+      (installerFactory.getNodejsDistribution as jest.Mock).mockReturnValue(
+        mockNodejsDistribution
+      );
+
+      await main.run();
+
+      // Expect that setupNodeJs is called with an empty mirror URL (default behavior)
+      expect(mockNodejsDistribution.setupNodeJs).toHaveBeenCalledWith(
+        expect.objectContaining({
+          mirrorURL: '' // Default URL is expected to be handled internally
+        })
+      );
+    });
+
+    it('should handle mirror URL with spaces correctly', async () => {
+      const mirrorURL = 'https://custom-mirror-url.com ';
+      const expectedTrimmedURL = 'https://custom-mirror-url.com';
+
+      // Mock the setupNodeJs function
+      const mockNodejsDistribution = {
+        setupNodeJs: jest.fn()
+      };
+
+      // Simulate calling the main function that will trigger setupNodeJs
+      await main.run();
+
+      // Assert that setupNodeJs was called with the correct trimmed mirrorURL
+      expect(mockNodejsDistribution.setupNodeJs).toHaveBeenCalledWith(
+        expect.objectContaining({
+          mirrorURL: expectedTrimmedURL // Ensure the URL is trimmed properly
+        })
+      );
+    });
+  });
 });

__tests__/official-installer.test.ts

@@ -9,9 +9,10 @@ import cp from 'child_process';
 import osm from 'os';
 import path from 'path';
 import * as main from '../src/main';
+import isLtsAlias from '../src/distributions/official_builds/official_builds';
 import * as auth from '../src/authutil';
 import OfficialBuilds from '../src/distributions/official_builds/official_builds';
-import {INodeVersion} from '../src/distributions/base-models';
+import {INodeVersion, NodeInputs} from '../src/distributions/base-models';
 
 import nodeTestManifest from './data/versions-manifest.json';
 import nodeTestDist from './data/node-dist-index.json';
@@ -828,4 +829,99 @@ describe('setup-node', () => {
       }
     );
   });
+
+  describe('OfficialBuilds - Mirror URL functionality', () => {
+    let officialBuilds: OfficialBuilds;
+
+    beforeEach(() => {
+      const mockNodeInfo = {
+        versionSpec: '16.x',
+        mirrorURL: 'https://my.custom.mirror/nodejs',
+        arch: 'x64',
+        stable: true,
+        checkLatest: false,
+        osPlat: 'linux' // Mock OS platform to avoid "undefined" error
+      };
+    });
+
+    it('should download using the mirror URL when provided', async () => {
+      // Mock data for nodeInfo
+      const nodeInfo: NodeInputs = {
+        versionSpec: '8.0.0-canary',
+        arch: 'x64',
+        checkLatest: false,
+        stable: false,
+        mirrorURL: 'https://my.custom.mirror/nodejs' // Mirror URL provided here
+      };
+
+      // Mock the core.info function to capture logs
+      const logSpy = jest.spyOn(core, 'info').mockImplementation(() => {});
+
+      // Mock the tc.downloadTool to simulate downloading
+      const mockDownloadPath = '/some/temp/path';
+      const mockDownloadTool = jest
+        .spyOn(tc, 'downloadTool')
+        .mockResolvedValue(mockDownloadPath);
+
+      // Mock core.addPath to avoid actual path changes
+      const mockAddPath = jest
+        .spyOn(core, 'addPath')
+        .mockImplementation(() => {});
+
+      // Mock the findSpy or any other necessary logic
+      findSpy.mockImplementation(() => nodeInfo);
+
+      // Call the function that will use the mirror URL and log the message
+      await main.run();
+
+      // Ensure downloadTool was called with the mirror URL
+      expect(mockDownloadTool).toHaveBeenCalledWith(
+        'https://my.custom.mirror/nodejs'
+      );
+
+      // Optionally, check that the download path was logged
+      expect(core.info).toHaveBeenCalledWith(
+        'downloadPath from downloadFromMirrorURL() /some/temp/path'
+      );
+
+      // Ensure the download path was added to the path
+      expect(mockAddPath).toHaveBeenCalledWith(mockDownloadPath);
+      expect(cnSpy).toHaveBeenCalledWith('https://my.custom.mirror/nodejs');
+    });
+
+    it('should log an error and handle failure during mirror URL download', async () => {
+      const errorMessage = 'Network error';
+
+      try {
+        // Act: Run the main function
+        await main.run();
+      } catch (error) {
+        // Expect core.error to be called with the error message
+        expect(core.error).toHaveBeenCalledWith(errorMessage);
+        expect(core.debug).toHaveBeenCalledWith(
+          expect.stringContaining('empty stack')
+        );
+      }
+    });
+
+    it('should log an error message if downloading from the mirror URL fails', async () => {
+      // Spy on core.setFailed
+      const setFailedSpy = jest
+        .spyOn(core, 'setFailed')
+        .mockImplementation(() => {});
+
+      // Mocking downloadFromMirrorURL to reject the promise and simulate a failure
+      dlSpy.mockImplementation(() =>
+        Promise.reject(new Error('Download failed'))
+      );
+
+      try {
+        // Call the function with the mirror URL
+        await main.run();
+      } catch (e) {
+        // Verifying if core.setFailed was called with the error message 'Download failed'
+        expect(setFailedSpy).toHaveBeenCalledWith('Download failed');
+      }
+    });
+  });
 });

dist/setup/index.js

@@ -100154,6 +100154,32 @@ class BaseDistribution {
             return response.result || [];
         });
     }
+    getMirrorUrlVersions() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const initialUrl = this.getDistributionUrl();
+            const dataUrl = `${initialUrl}/index.json`;
+            try {
+                const response = yield this.httpClient.getJson(dataUrl);
+                return response.result || [];
+            }
+            catch (err) {
+                if (err instanceof Error &&
+                    err.message.includes('getaddrinfo EAI_AGAIN')) {
+                    core.error(`Network error: Failed to resolve the server at ${dataUrl}. 
+                      Please check your DNS settings or verify that the URL is correct.`);
+                }
+                else if (err instanceof hc.HttpClientError && err.statusCode === 404) {
+                    core.error(`404 Error: Unable to find versions at ${dataUrl}. 
+                      Please verify that the mirror URL is valid.`);
+                }
+                else {
+                    core.error(`Failed to fetch Node.js versions from ${dataUrl}. 
+                      Please check the URL and try again.}`);
+                }
+                throw err;
+            }
+        });
+    }
     getNodejsDistInfo(version) {
         const osArch = this.translateArchToDistUrl(this.nodeInfo.arch);
         version = semver_1.default.clean(version) || '';
@@ -100174,6 +100200,26 @@ class BaseDistribution {
             fileName: fileName
         };
     }
+    getNodejsMirrorURLInfo(version) {
+        const mirrorURL = this.nodeInfo.mirrorURL;
+        const osArch = this.translateArchToDistUrl(this.nodeInfo.arch);
+        version = semver_1.default.clean(version) || '';
+        const fileName = this.osPlat == 'win32'
+            ? `node-v${version}-win-${osArch}`
+            : `node-v${version}-${this.osPlat}-${osArch}`;
+        const urlFileName = this.osPlat == 'win32'
+            ? this.nodeInfo.arch === 'arm64'
+                ? `${fileName}.zip`
+                : `${fileName}.7z`
+            : `${fileName}.tar.gz`;
+        const url = `${mirrorURL}/v${version}/${urlFileName}`;
+        return {
+            downloadUrl: url,
+            resolvedVersion: version,
+            arch: osArch,
+            fileName: fileName
+        };
+    }
     downloadNodejs(info) {
         return __awaiter(this, void 0, void 0, function* () {
             let downloadPath = '';
@@ -100185,8 +100231,15 @@ class BaseDistribution {
                 if (err instanceof tc.HTTPError &&
                     err.httpStatusCode == 404 &&
                     this.osPlat == 'win32') {
-                    return yield this.acquireWindowsNodeFromFallbackLocation(info.resolvedVersion, info.arch);
+                    return yield this.acquireWindowsNodeFromFallbackLocation(info.resolvedVersion, info.arch, info.downloadUrl);
                 }
+                // Handle network-related issues (e.g., DNS resolution failures)
+                if (err instanceof Error &&
+                    err.message.includes('getaddrinfo EAI_AGAIN')) {
+                    core.error(`Network error: Failed to resolve the server at ${info.downloadUrl}. 
+            This could be due to a DNS resolution issue. Please verify the URL or check your network connection.`);
+                }
+                core.error(`Download failed from ${info.downloadUrl}. Please check the URl and try again.`);
                 throw err;
             }
             const toolPath = yield this.extractArchive(downloadPath, info, true);
@@ -100202,8 +100255,9 @@ class BaseDistribution {
         return { range: valid, options };
     }
     acquireWindowsNodeFromFallbackLocation(version_1) {
-        return __awaiter(this, arguments, void 0, function* (version, arch = os_1.default.arch()) {
+        return __awaiter(this, arguments, void 0, function* (version, arch = os_1.default.arch(), downloadUrl) {
             const initialUrl = this.getDistributionUrl();
+            core.info('url: ' + initialUrl);
             const osArch = this.translateArchToDistUrl(arch);
             // Create temporary folder to download to
             const tempDownloadFolder = `temp_${(0, uuid_1.v4)()}`;
@@ -100217,6 +100271,9 @@ class BaseDistribution {
                 exeUrl = `${initialUrl}/v${version}/win-${osArch}/node.exe`;
                 libUrl = `${initialUrl}/v${version}/win-${osArch}/node.lib`;
                 core.info(`Downloading only node binary from ${exeUrl}`);
+                if (downloadUrl != exeUrl) {
+                    core.error('unable to download node binary with the provided URL. Please check and try again');
+                }
                 const exePath = yield tc.downloadTool(exeUrl);
                 yield io.cp(exePath, path.join(tempDir, 'node.exe'));
                 const libPath = yield tc.downloadTool(libUrl);
@@ -100381,18 +100438,59 @@ exports.getNodejsDistribution = getNodejsDistribution;
 
 "use strict";
 
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 const base_distribution_prerelease_1 = __importDefault(__nccwpck_require__(957));
+const core = __importStar(__nccwpck_require__(2186));
 class NightlyNodejs extends base_distribution_prerelease_1.default {
     constructor(nodeInfo) {
         super(nodeInfo);
         this.distribution = 'nightly';
     }
     getDistributionUrl() {
-        return 'https://nodejs.org/download/nightly';
+        if (this.nodeInfo.mirrorURL) {
+            if (this.nodeInfo.mirrorURL != '') {
+                core.info('Download using Using mirror URL for nightly Node.js.');
+                return this.nodeInfo.mirrorURL;
+            }
+            else {
+                if (this.nodeInfo.mirrorURL === '') {
+                    throw new Error('Mirror URL is empty. Please provide a valid mirror URL.');
+                }
+                else {
+                    throw new Error('Mirror URL is not a valid');
+                }
+            }
+        }
+        else {
+            core.info('Using default distribution URL for nightly Node.js.');
+            return 'https://nodejs.org/download/nightly';
+        }
     }
 }
 exports["default"] = NightlyNodejs;
@@ -100451,73 +100549,93 @@ class OfficialBuilds extends base_distribution_1.default {
     }
     setupNodeJs() {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            let manifest;
-            let nodeJsVersions;
-            const osArch = this.translateArchToDistUrl(this.nodeInfo.arch);
-            if (this.isLtsAlias(this.nodeInfo.versionSpec)) {
-                core.info('Attempt to resolve LTS alias from manifest...');
-                // No try-catch since it's not possible to resolve LTS alias without manifest
-                manifest = yield this.getManifest();
-                this.nodeInfo.versionSpec = this.resolveLtsAliasFromManifest(this.nodeInfo.versionSpec, this.nodeInfo.stable, manifest);
-            }
-            if (this.isLatestSyntax(this.nodeInfo.versionSpec)) {
-                nodeJsVersions = yield this.getNodeJsVersions();
-                const versions = this.filterVersions(nodeJsVersions);
-                this.nodeInfo.versionSpec = this.evaluateVersions(versions);
-                core.info('getting latest node version...');
-            }
-            if (this.nodeInfo.checkLatest) {
-                core.info('Attempt to resolve the latest version from manifest...');
-                const resolvedVersion = yield this.resolveVersionFromManifest(this.nodeInfo.versionSpec, this.nodeInfo.stable, osArch, manifest);
-                if (resolvedVersion) {
-                    this.nodeInfo.versionSpec = resolvedVersion;
-                    core.info(`Resolved as '${resolvedVersion}'`);
-                }
-                else {
-                    core.info(`Failed to resolve version ${this.nodeInfo.versionSpec} from manifest`);
-                }
-            }
-            let toolPath = this.findVersionInHostedToolCacheDirectory();
-            if (toolPath) {
-                core.info(`Found in cache @ ${toolPath}`);
-                this.addToolPath(toolPath);
-                return;
-            }
-            let downloadPath = '';
-            try {
-                core.info(`Attempting to download ${this.nodeInfo.versionSpec}...`);
-                const versionInfo = yield this.getInfoFromManifest(this.nodeInfo.versionSpec, this.nodeInfo.stable, osArch, manifest);
-                if (versionInfo) {
-                    core.info(`Acquiring ${versionInfo.resolvedVersion} - ${versionInfo.arch} from ${versionInfo.downloadUrl}`);
-                    downloadPath = yield tc.downloadTool(versionInfo.downloadUrl, undefined, this.nodeInfo.auth);
+            var _a, _b;
+            if (this.nodeInfo.mirrorURL) {
+                let downloadPath = '';
+                try {
+                    core.info(`Attempting to download using mirror URL...`);
+                    downloadPath = yield this.downloadFromMirrorURL(); // Attempt to download from the mirror
+                    core.info('downloadPath from downloadFromMirrorURL() ' + downloadPath);
                     if (downloadPath) {
-                        toolPath = yield this.extractArchive(downloadPath, versionInfo, false);
+                        const toolPath = downloadPath;
                     }
                 }
-                else {
-                    core.info('Not found in manifest. Falling back to download directly from Node');
-                }
-            }
-            catch (err) {
-                // Rate limit?
-                if (err instanceof tc.HTTPError &&
-                    (err.httpStatusCode === 403 || err.httpStatusCode === 429)) {
-                    core.info(`Received HTTP status code ${err.httpStatusCode}. This usually indicates the rate limit has been exceeded`);
-                }
-                else {
+                catch (err) {
                     core.info(err.message);
+                    core.info('Download failed');
+                    core.debug((_a = err.stack) !== null && _a !== void 0 ? _a : 'empty stack');
                 }
-                core.debug((_a = err.stack) !== null && _a !== void 0 ? _a : 'empty stack');
-                core.info('Falling back to download directly from Node');
             }
-            if (!toolPath) {
-                toolPath = yield this.downloadDirectlyFromNode();
+            else {
+                core.info('No mirror URL found. Falling back to default setup...');
+                core.info('Setup Node.js');
+                let manifest;
+                let nodeJsVersions;
+                const osArch = this.translateArchToDistUrl(this.nodeInfo.arch);
+                if (this.isLtsAlias(this.nodeInfo.versionSpec)) {
+                    core.info('Attempt to resolve LTS alias from manifest...');
+                    // No try-catch since it's not possible to resolve LTS alias without manifest
+                    manifest = yield this.getManifest();
+                    this.nodeInfo.versionSpec = this.resolveLtsAliasFromManifest(this.nodeInfo.versionSpec, this.nodeInfo.stable, manifest);
+                }
+                if (this.isLatestSyntax(this.nodeInfo.versionSpec)) {
+                    nodeJsVersions = yield this.getNodeJsVersions();
+                    const versions = this.filterVersions(nodeJsVersions);
+                    this.nodeInfo.versionSpec = this.evaluateVersions(versions);
+                    core.info('getting latest node version...');
+                }
+                if (this.nodeInfo.checkLatest) {
+                    core.info('Attempt to resolve the latest version from manifest...');
+                    const resolvedVersion = yield this.resolveVersionFromManifest(this.nodeInfo.versionSpec, this.nodeInfo.stable, osArch, manifest);
+                    if (resolvedVersion) {
+                        this.nodeInfo.versionSpec = resolvedVersion;
+                        core.info(`Resolved as '${resolvedVersion}'`);
+                    }
+                    else {
+                        core.info(`Failed to resolve version ${this.nodeInfo.versionSpec} from manifest`);
+                    }
+                }
+                let toolPath = this.findVersionInHostedToolCacheDirectory();
+                if (toolPath) {
+                    core.info(`Found in cache @ ${toolPath}`);
+                    this.addToolPath(toolPath);
+                    return;
+                }
+                let downloadPath = '';
+                try {
+                    core.info(`Attempting to download ${this.nodeInfo.versionSpec}...`);
+                    const versionInfo = yield this.getInfoFromManifest(this.nodeInfo.versionSpec, this.nodeInfo.stable, osArch, manifest);
+                    if (versionInfo) {
+                        core.info(`Acquiring ${versionInfo.resolvedVersion} - ${versionInfo.arch} from ${versionInfo.downloadUrl}`);
+                        downloadPath = yield tc.downloadTool(versionInfo.downloadUrl, undefined, this.nodeInfo.auth);
+                        if (downloadPath) {
+                            toolPath = yield this.extractArchive(downloadPath, versionInfo, false);
+                        }
+                    }
+                    else {
+                        core.info('Not found in manifest. Falling back to download directly from Node');
+                    }
+                }
+                catch (err) {
+                    // Rate limit?
+                    if (err instanceof tc.HTTPError &&
+                        (err.httpStatusCode === 403 || err.httpStatusCode === 429)) {
+                        core.info(`Received HTTP status code ${err.httpStatusCode}. This usually indicates the rate limit has been exceeded`);
+                    }
+                    else {
+                        core.info(err.message);
+                    }
+                    core.debug((_b = err.stack) !== null && _b !== void 0 ? _b : 'empty stack');
+                    core.info('Falling back to download directly from Node');
+                }
+                if (!toolPath) {
+                    toolPath = yield this.downloadDirectlyFromNode();
+                }
+                if (this.osPlat != 'win32') {
+                    toolPath = path_1.default.join(toolPath, 'bin');
+                }
+                core.addPath(toolPath);
             }
-            if (this.osPlat != 'win32') {
-                toolPath = path_1.default.join(toolPath, 'bin');
-            }
-            core.addPath(toolPath);
         });
     }
     addToolPath(toolPath) {
@@ -100559,6 +100677,9 @@ class OfficialBuilds extends base_distribution_1.default {
         return version;
     }
     getDistributionUrl() {
+        if (this.nodeInfo.mirrorURL) {
+            return this.nodeInfo.mirrorURL;
+        }
         return `https://nodejs.org/dist`;
     }
     getManifest() {
@@ -100626,6 +100747,33 @@ class OfficialBuilds extends base_distribution_1.default {
     isLatestSyntax(versionSpec) {
         return ['current', 'latest', 'node'].includes(versionSpec);
     }
+    downloadFromMirrorURL() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const nodeJsVersions = yield this.getMirrorUrlVersions();
+            const versions = this.filterVersions(nodeJsVersions);
+            const evaluatedVersion = this.evaluateVersions(versions);
+            if (!evaluatedVersion) {
+                throw new Error(`Unable to find Node version '${this.nodeInfo.versionSpec}' for platform ${this.osPlat} and architecture ${this.nodeInfo.arch} from the provided mirror-url ${this.nodeInfo.mirrorURL}. Please check the mirror-url`);
+            }
+            const toolName = this.getNodejsMirrorURLInfo(evaluatedVersion);
+            try {
+                const toolPath = yield this.downloadNodejs(toolName);
+                return toolPath;
+            }
+            catch (error) {
+                if (error instanceof tc.HTTPError && error.httpStatusCode === 404) {
+                    core.error(`Node version ${this.nodeInfo.versionSpec} for platform ${this.osPlat} and architecture ${this.nodeInfo.arch} was found but failed to download. ` +
+                        'This usually happens when downloadable binaries are not fully updated at https://nodejs.org/. ' +
+                        'To resolve this issue you may either fall back to the older version or try again later.');
+                }
+                else {
+                    // For any other error type, you can log the error message.
+                    core.error(`An unexpected error occurred like url might not correct`);
+                }
+                throw error;
+            }
+        });
+    }
 }
 exports["default"] = OfficialBuilds;
 
@@ -100647,7 +100795,22 @@ class RcBuild extends base_distribution_1.default {
         super(nodeInfo);
     }
     getDistributionUrl() {
-        return 'https://nodejs.org/download/rc';
+        if (this.nodeInfo.mirrorURL) {
+            if (this.nodeInfo.mirrorURL != '') {
+                return this.nodeInfo.mirrorURL;
+            }
+            else {
+                if (this.nodeInfo.mirrorURL === '') {
+                    throw new Error('Mirror URL is empty. Please provide a valid mirror URL.');
+                }
+                else {
+                    throw new Error('Mirror URL is not a valid');
+                }
+            }
+        }
+        else {
+            return 'https://nodejs.org/download/rc';
+        }
     }
 }
 exports["default"] = RcBuild;
@@ -100671,7 +100834,22 @@ class CanaryBuild extends base_distribution_prerelease_1.default {
         this.distribution = 'v8-canary';
     }
     getDistributionUrl() {
-        return 'https://nodejs.org/download/v8-canary';
+        if (this.nodeInfo.mirrorURL) {
+            if (this.nodeInfo.mirrorURL != '') {
+                return this.nodeInfo.mirrorURL;
+            }
+            else {
+                if (this.nodeInfo.mirrorURL === '') {
+                    throw new Error('Mirror URL is empty. Please provide a valid mirror URL.');
+                }
+                else {
+                    throw new Error('Mirror URL is not a valid');
+                }
+            }
+        }
+        else {
+            return 'https://nodejs.org/download/v8-canary';
+        }
     }
 }
 exports["default"] = CanaryBuild;
@@ -100720,7 +100898,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.run = void 0;
+exports.setupNodeJs = exports.run = void 0;
 const core = __importStar(__nccwpck_require__(2186));
 const os_1 = __importDefault(__nccwpck_require__(2037));
 const auth = __importStar(__nccwpck_require__(7573));
@@ -100748,6 +100926,10 @@ function run() {
             if (!arch) {
                 arch = os_1.default.arch();
             }
+            const mirrorURL = core.getInput('mirror-url');
+            if (mirrorURL === ' ' && mirrorURL === undefined) {
+                core.error('Mirror URL is emptry or undefined. The default mirror URL will be used.');
+            }
             if (version) {
                 const token = core.getInput('token');
                 const auth = !token ? undefined : `token ${token}`;
@@ -100758,7 +100940,8 @@ function run() {
                     checkLatest,
                     auth,
                     stable,
-                    arch
+                    arch,
+                    mirrorURL
                 };
                 const nodeDistribution = (0, installer_factory_1.getNodejsDistribution)(nodejsInfo);
                 yield nodeDistribution.setupNodeJs();
@@ -100807,6 +100990,10 @@ function resolveVersionInput() {
     }
     return version;
 }
+function setupNodeJs(mirrorURL) {
+    throw new Error('Function not implemented.');
+}
+exports.setupNodeJs = setupNodeJs;
 
 
 /***/ }),

src/distributions/base-distribution.ts

@@ -104,6 +104,31 @@ export default abstract class BaseDistribution {
     return response.result || [];
   }
 
+  protected async getMirrorUrlVersions(): Promise<INodeVersion[]> {
+    const initialUrl = this.getDistributionUrl();
+
+    const dataUrl = `${initialUrl}/index.json`;
+    try {
+      const response = await this.httpClient.getJson<INodeVersion[]>(dataUrl);
+      return response.result || [];
+    } catch (err) {
+      if (
+        err instanceof Error &&
+        err.message.includes('getaddrinfo EAI_AGAIN')
+      ) {
+        core.error(`Network error: Failed to resolve the server at ${dataUrl}. 
+                      Please check your DNS settings or verify that the URL is correct.`);
+      } else if (err instanceof hc.HttpClientError && err.statusCode === 404) {
+        core.error(`404 Error: Unable to find versions at ${dataUrl}. 
+                      Please verify that the mirror URL is valid.`);
+      } else {
+        core.error(`Failed to fetch Node.js versions from ${dataUrl}. 
+                      Please check the URL and try again.}`);
+      }
+      throw err;
+    }
+  }
+
   protected getNodejsDistInfo(version: string) {
     const osArch: string = this.translateArchToDistUrl(this.nodeInfo.arch);
     version = semver.clean(version) || '';
@@ -128,6 +153,33 @@ export default abstract class BaseDistribution {
     };
   }
 
+  protected getNodejsMirrorURLInfo(version: string) {
+    const mirrorURL = this.nodeInfo.mirrorURL;
+
+    const osArch: string = this.translateArchToDistUrl(this.nodeInfo.arch);
+
+    version = semver.clean(version) || '';
+    const fileName: string =
+      this.osPlat == 'win32'
+        ? `node-v${version}-win-${osArch}`
+        : `node-v${version}-${this.osPlat}-${osArch}`;
+    const urlFileName: string =
+      this.osPlat == 'win32'
+        ? this.nodeInfo.arch === 'arm64'
+          ? `${fileName}.zip`
+          : `${fileName}.7z`
+        : `${fileName}.tar.gz`;
+
+    const url = `${mirrorURL}/v${version}/${urlFileName}`;
+
+    return <INodeVersionInfo>{
+      downloadUrl: url,
+      resolvedVersion: version,
+      arch: osArch,
+      fileName: fileName
+    };
+  }
+
   protected async downloadNodejs(info: INodeVersionInfo) {
     let downloadPath = '';
     core.info(
@@ -143,9 +195,23 @@ export default abstract class BaseDistribution {
       ) {
         return await this.acquireWindowsNodeFromFallbackLocation(
           info.resolvedVersion,
-          info.arch
+          info.arch,
+          info.downloadUrl
         );
       }
+      // Handle network-related issues (e.g., DNS resolution failures)
+      if (
+        err instanceof Error &&
+        err.message.includes('getaddrinfo EAI_AGAIN')
+      ) {
+        core.error(
+          `Network error: Failed to resolve the server at ${info.downloadUrl}. 
+            This could be due to a DNS resolution issue. Please verify the URL or check your network connection.`
+        );
+      }
+      core.error(
+        `Download failed from ${info.downloadUrl}. Please check the URl and try again.`
+      );
 
       throw err;
     }
@@ -166,9 +232,11 @@ export default abstract class BaseDistribution {
 
   protected async acquireWindowsNodeFromFallbackLocation(
     version: string,
-    arch: string = os.arch()
+    arch: string = os.arch(),
+    downloadUrl: string
   ): Promise<string> {
     const initialUrl = this.getDistributionUrl();
+    core.info('url: ' + initialUrl);
     const osArch: string = this.translateArchToDistUrl(arch);
 
     // Create temporary folder to download to
@@ -185,6 +253,12 @@ export default abstract class BaseDistribution {
 
       core.info(`Downloading only node binary from ${exeUrl}`);
 
+      if (downloadUrl != exeUrl) {
+        core.error(
+          'unable to download node binary with the provided URL. Please check and try again'
+        );
+      }
+
       const exePath = await tc.downloadTool(exeUrl);
       await io.cp(exePath, path.join(tempDir, 'node.exe'));
       const libPath = await tc.downloadTool(libUrl);

src/distributions/base-models.ts

@@ -4,6 +4,7 @@ export interface NodeInputs {
   auth?: string;
   checkLatest: boolean;
   stable: boolean;
+  mirrorURL?: string;
 }
 
 export interface INodeVersionInfo {

src/distributions/nightly/nightly_builds.ts

@@ -3,11 +3,26 @@ import {NodeInputs} from '../base-models';
 
 export default class NightlyNodejs extends BasePrereleaseNodejs {
   protected distribution = 'nightly';
+
   constructor(nodeInfo: NodeInputs) {
     super(nodeInfo);
   }
 
   protected getDistributionUrl(): string {
-    return 'https://nodejs.org/download/nightly';
+    if (this.nodeInfo.mirrorURL) {
+      if (this.nodeInfo.mirrorURL != '') {
+        return this.nodeInfo.mirrorURL;
+      } else {
+        if (this.nodeInfo.mirrorURL === '') {
+          throw new Error(
+            'Mirror URL is empty. Please provide a valid mirror URL.'
+          );
+        } else {
+          throw new Error('Mirror URL is not a valid');
+        }
+      }
+    } else {
+      return 'https://nodejs.org/download/nightly';
+    }
   }
 }

src/distributions/official_builds/official_builds.ts

@@ -15,115 +15,134 @@ export default class OfficialBuilds extends BaseDistribution {
   }
 
   public async setupNodeJs() {
-    let manifest: tc.IToolRelease[] | undefined;
-    let nodeJsVersions: INodeVersion[] | undefined;
-    const osArch = this.translateArchToDistUrl(this.nodeInfo.arch);
+    if (this.nodeInfo.mirrorURL) {
+      let downloadPath = '';
 
-    if (this.isLtsAlias(this.nodeInfo.versionSpec)) {
-      core.info('Attempt to resolve LTS alias from manifest...');
+      try {
+        core.info(`Attempting to download using mirror URL...`);
+        downloadPath = await this.downloadFromMirrorURL(); // Attempt to download from the mirror
+        core.info('downloadPath from downloadFromMirrorURL() ' + downloadPath);
+        if (downloadPath) {
+          const toolPath = downloadPath;
+        }
+      } catch (err) {
+        core.info((err as Error).message);
+        core.info('Download failed');
+        core.debug((err as Error).stack ?? 'empty stack');
+      }
+    } else {
+      core.info('No mirror URL found. Falling back to default setup...');
+      core.info('Setup Node.js');
+      let manifest: tc.IToolRelease[] | undefined;
+      let nodeJsVersions: INodeVersion[] | undefined;
+      const osArch = this.translateArchToDistUrl(this.nodeInfo.arch);
 
-      // No try-catch since it's not possible to resolve LTS alias without manifest
-      manifest = await this.getManifest();
+      if (this.isLtsAlias(this.nodeInfo.versionSpec)) {
+        core.info('Attempt to resolve LTS alias from manifest...');
 
-      this.nodeInfo.versionSpec = this.resolveLtsAliasFromManifest(
-        this.nodeInfo.versionSpec,
-        this.nodeInfo.stable,
-        manifest
-      );
-    }
+        // No try-catch since it's not possible to resolve LTS alias without manifest
+        manifest = await this.getManifest();
 
-    if (this.isLatestSyntax(this.nodeInfo.versionSpec)) {
-      nodeJsVersions = await this.getNodeJsVersions();
-      const versions = this.filterVersions(nodeJsVersions);
-      this.nodeInfo.versionSpec = this.evaluateVersions(versions);
-
-      core.info('getting latest node version...');
-    }
-
-    if (this.nodeInfo.checkLatest) {
-      core.info('Attempt to resolve the latest version from manifest...');
-      const resolvedVersion = await this.resolveVersionFromManifest(
-        this.nodeInfo.versionSpec,
-        this.nodeInfo.stable,
-        osArch,
-        manifest
-      );
-      if (resolvedVersion) {
-        this.nodeInfo.versionSpec = resolvedVersion;
-        core.info(`Resolved as '${resolvedVersion}'`);
-      } else {
-        core.info(
-          `Failed to resolve version ${this.nodeInfo.versionSpec} from manifest`
+        this.nodeInfo.versionSpec = this.resolveLtsAliasFromManifest(
+          this.nodeInfo.versionSpec,
+          this.nodeInfo.stable,
+          manifest
         );
       }
-    }
 
-    let toolPath = this.findVersionInHostedToolCacheDirectory();
+      if (this.isLatestSyntax(this.nodeInfo.versionSpec)) {
+        nodeJsVersions = await this.getNodeJsVersions();
+        const versions = this.filterVersions(nodeJsVersions);
+        this.nodeInfo.versionSpec = this.evaluateVersions(versions);
 
-    if (toolPath) {
-      core.info(`Found in cache @ ${toolPath}`);
-      this.addToolPath(toolPath);
-      return;
-    }
+        core.info('getting latest node version...');
+      }
 
-    let downloadPath = '';
-    try {
-      core.info(`Attempting to download ${this.nodeInfo.versionSpec}...`);
-
-      const versionInfo = await this.getInfoFromManifest(
-        this.nodeInfo.versionSpec,
-        this.nodeInfo.stable,
-        osArch,
-        manifest
-      );
-
-      if (versionInfo) {
-        core.info(
-          `Acquiring ${versionInfo.resolvedVersion} - ${versionInfo.arch} from ${versionInfo.downloadUrl}`
+      if (this.nodeInfo.checkLatest) {
+        core.info('Attempt to resolve the latest version from manifest...');
+        const resolvedVersion = await this.resolveVersionFromManifest(
+          this.nodeInfo.versionSpec,
+          this.nodeInfo.stable,
+          osArch,
+          manifest
         );
-        downloadPath = await tc.downloadTool(
-          versionInfo.downloadUrl,
-          undefined,
-          this.nodeInfo.auth
-        );
-
-        if (downloadPath) {
-          toolPath = await this.extractArchive(
-            downloadPath,
-            versionInfo,
-            false
+        if (resolvedVersion) {
+          this.nodeInfo.versionSpec = resolvedVersion;
+          core.info(`Resolved as '${resolvedVersion}'`);
+        } else {
+          core.info(
+            `Failed to resolve version ${this.nodeInfo.versionSpec} from manifest`
           );
         }
-      } else {
-        core.info(
-          'Not found in manifest. Falling back to download directly from Node'
-        );
       }
-    } catch (err) {
-      // Rate limit?
-      if (
-        err instanceof tc.HTTPError &&
-        (err.httpStatusCode === 403 || err.httpStatusCode === 429)
-      ) {
-        core.info(
-          `Received HTTP status code ${err.httpStatusCode}. This usually indicates the rate limit has been exceeded`
-        );
-      } else {
-        core.info((err as Error).message);
+
+      let toolPath = this.findVersionInHostedToolCacheDirectory();
+
+      if (toolPath) {
+        core.info(`Found in cache @ ${toolPath}`);
+        this.addToolPath(toolPath);
+        return;
       }
-      core.debug((err as Error).stack ?? 'empty stack');
-      core.info('Falling back to download directly from Node');
-    }
 
-    if (!toolPath) {
-      toolPath = await this.downloadDirectlyFromNode();
-    }
+      let downloadPath = '';
+      try {
+        core.info(`Attempting to download ${this.nodeInfo.versionSpec}...`);
 
-    if (this.osPlat != 'win32') {
-      toolPath = path.join(toolPath, 'bin');
-    }
+        const versionInfo = await this.getInfoFromManifest(
+          this.nodeInfo.versionSpec,
+          this.nodeInfo.stable,
+          osArch,
+          manifest
+        );
 
-    core.addPath(toolPath);
+        if (versionInfo) {
+          core.info(
+            `Acquiring ${versionInfo.resolvedVersion} - ${versionInfo.arch} from ${versionInfo.downloadUrl}`
+          );
+          downloadPath = await tc.downloadTool(
+            versionInfo.downloadUrl,
+            undefined,
+            this.nodeInfo.auth
+          );
+
+          if (downloadPath) {
+            toolPath = await this.extractArchive(
+              downloadPath,
+              versionInfo,
+              false
+            );
+          }
+        } else {
+          core.info(
+            'Not found in manifest. Falling back to download directly from Node'
+          );
+        }
+      } catch (err) {
+        // Rate limit?
+        if (
+          err instanceof tc.HTTPError &&
+          (err.httpStatusCode === 403 || err.httpStatusCode === 429)
+        ) {
+          core.info(
+            `Received HTTP status code ${err.httpStatusCode}. This usually indicates the rate limit has been exceeded`
+          );
+        } else {
+          core.info((err as Error).message);
+        }
+        core.debug((err as Error).stack ?? 'empty stack');
+        core.info('Falling back to download directly from Node');
+      }
+
+      if (!toolPath) {
+        toolPath = await this.downloadDirectlyFromNode();
+      }
+
+      if (this.osPlat != 'win32') {
+        toolPath = path.join(toolPath, 'bin');
+      }
+
+      core.addPath(toolPath);
+    }
   }
 
   protected addToolPath(toolPath: string) {
@@ -177,6 +196,9 @@ export default class OfficialBuilds extends BaseDistribution {
   }
 
   protected getDistributionUrl(): string {
+    if (this.nodeInfo.mirrorURL) {
+      return this.nodeInfo.mirrorURL;
+    }
     return `https://nodejs.org/dist`;
   }
 
@@ -291,4 +313,38 @@ export default class OfficialBuilds extends BaseDistribution {
   private isLatestSyntax(versionSpec): boolean {
     return ['current', 'latest', 'node'].includes(versionSpec);
   }
+
+  protected async downloadFromMirrorURL() {
+    const nodeJsVersions = await this.getMirrorUrlVersions();
+    const versions = this.filterVersions(nodeJsVersions);
+
+    const evaluatedVersion = this.evaluateVersions(versions);
+
+    if (!evaluatedVersion) {
+      throw new Error(
+        `Unable to find Node version '${this.nodeInfo.versionSpec}' for platform ${this.osPlat} and architecture ${this.nodeInfo.arch} from the provided mirror-url ${this.nodeInfo.mirrorURL}. Please check the mirror-url`
+      );
+    }
+
+    const toolName = this.getNodejsMirrorURLInfo(evaluatedVersion);
+
+    try {
+      const toolPath = await this.downloadNodejs(toolName);
+
+      return toolPath;
+    } catch (error) {
+      if (error instanceof tc.HTTPError && error.httpStatusCode === 404) {
+        core.error(
+          `Node version ${this.nodeInfo.versionSpec} for platform ${this.osPlat} and architecture ${this.nodeInfo.arch} was found but failed to download. ` +
+            'This usually happens when downloadable binaries are not fully updated at https://nodejs.org/. ' +
+            'To resolve this issue you may either fall back to the older version or try again later.'
+        );
+      } else {
+        // For any other error type, you can log the error message.
+        core.error(`An unexpected error occurred like url might not correct`);
+      }
+
+      throw error;
+    }
+  }
 }

src/distributions/rc/rc_builds.ts

@@ -5,8 +5,21 @@ export default class RcBuild extends BaseDistribution {
   constructor(nodeInfo: NodeInputs) {
     super(nodeInfo);
   }
-
-  getDistributionUrl(): string {
-    return 'https://nodejs.org/download/rc';
+  protected getDistributionUrl(): string {
+    if (this.nodeInfo.mirrorURL) {
+      if (this.nodeInfo.mirrorURL != '') {
+        return this.nodeInfo.mirrorURL;
+      } else {
+        if (this.nodeInfo.mirrorURL === '') {
+          throw new Error(
+            'Mirror URL is empty. Please provide a valid mirror URL.'
+          );
+        } else {
+          throw new Error('Mirror URL is not a valid');
+        }
+      }
+    } else {
+      return 'https://nodejs.org/download/rc';
+    }
   }
 }

src/distributions/v8-canary/canary_builds.ts

@@ -1,6 +1,5 @@
 import BasePrereleaseNodejs from '../base-distribution-prerelease';
 import {NodeInputs} from '../base-models';
-
 export default class CanaryBuild extends BasePrereleaseNodejs {
   protected distribution = 'v8-canary';
   constructor(nodeInfo: NodeInputs) {
@@ -8,6 +7,20 @@ export default class CanaryBuild extends BasePrereleaseNodejs {
   }
 
   protected getDistributionUrl(): string {
-    return 'https://nodejs.org/download/v8-canary';
+    if (this.nodeInfo.mirrorURL) {
+      if (this.nodeInfo.mirrorURL != '') {
+        return this.nodeInfo.mirrorURL;
+      } else {
+        if (this.nodeInfo.mirrorURL === '') {
+          throw new Error(
+            'Mirror URL is empty. Please provide a valid mirror URL.'
+          );
+        } else {
+          throw new Error('Mirror URL is not a valid');
+        }
+      }
+    } else {
+      return 'https://nodejs.org/download/v8-canary';
+    }
   }
 }

src/main.ts

@@ -33,6 +33,13 @@ export async function run() {
       arch = os.arch();
     }
 
+    const mirrorURL = core.getInput('mirror-url');
+    if (mirrorURL === ' ' && mirrorURL === undefined) {
+      core.error(
+        'Mirror URL is emptry or undefined. The default mirror URL will be used.'
+      );
+    }
+
     if (version) {
       const token = core.getInput('token');
       const auth = !token ? undefined : `token ${token}`;
@@ -45,7 +52,8 @@ export async function run() {
         checkLatest,
         auth,
         stable,
-        arch
+        arch,
+        mirrorURL
       };
       const nodeDistribution = getNodejsDistribution(nodejsInfo);
       await nodeDistribution.setupNodeJs();
@@ -113,3 +121,6 @@ function resolveVersionInput(): string {
 
   return version;
 }
+export function setupNodeJs(mirrorURL: string) {
+  throw new Error('Function not implemented.');
+}