nx 20.8.4 → 22.7.7

package/dist/src/nx-cloud/update-manager.js

@@ -0,0 +1,267 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NxCloudClientUnavailableError = exports.NxCloudEnterpriseOutdatedError = void 0;
+exports.verifyOrUpdateNxCloudClient = verifyOrUpdateNxCloudClient;
+exports.getBundleInstallDefaultLocation = getBundleInstallDefaultLocation;
+const tslib_1 = require("tslib");
+const fs_1 = require("fs");
+const zlib_1 = require("zlib");
+const path_1 = require("path");
+const os_1 = require("os");
+const axios_1 = require("./utilities/axios");
+const debug_logger_1 = require("./debug-logger");
+const tar = tslib_1.__importStar(require("tar-stream"));
+const cache_directory_1 = require("../utils/cache-directory");
+const crypto_1 = require("crypto");
+const workspace_root_1 = require("../utils/workspace-root");
+class NxCloudEnterpriseOutdatedError extends Error {
+    constructor(url) {
+        super(`Nx Cloud instance hosted at ${url} is outdated`);
+    }
+}
+exports.NxCloudEnterpriseOutdatedError = NxCloudEnterpriseOutdatedError;
+class NxCloudClientUnavailableError extends Error {
+    constructor() {
+        super('No existing Nx Cloud client and failed to download new version');
+    }
+}
+exports.NxCloudClientUnavailableError = NxCloudClientUnavailableError;
+async function verifyOrUpdateNxCloudClient(options) {
+    (0, debug_logger_1.debugLog)('Verifying current cloud bundle');
+    const currentBundle = getLatestInstalledRunnerBundle();
+    const apiUrl = process.env.NX_CLOUD_API || options?.url || 'https://cloud.nx.app';
+    if (shouldVerifyInstalledRunnerBundle(currentBundle)) {
+        const axios = (0, axios_1.createApiAxiosInstance)(options);
+        let verifyBundleResponse;
+        try {
+            verifyBundleResponse = await verifyCurrentBundle(axios, currentBundle);
+        }
+        catch (e) {
+            // Enterprise image compatibility, to be removed
+            if (e.message === 'Request failed with status code 404' && apiUrl) {
+                throw new NxCloudEnterpriseOutdatedError(apiUrl);
+            }
+            (0, debug_logger_1.debugLog)('Could not verify bundle. Resetting validation timer and using previously installed or default runner. Error: ', e);
+            writeBundleVerificationLock();
+            if (currentBundle === null) {
+                throw new NxCloudClientUnavailableError();
+            }
+            if (currentBundle.version === 'NX_ENTERPRISE_OUTDATED_IMAGE') {
+                throw new NxCloudEnterpriseOutdatedError(apiUrl);
+            }
+            const nxCloudClient = require(currentBundle.fullPath);
+            if (nxCloudClient.commands === undefined) {
+                throw new NxCloudEnterpriseOutdatedError(apiUrl);
+            }
+            return {
+                version: currentBundle.version,
+                nxCloudClient,
+            };
+        }
+        if (verifyBundleResponse.data.valid) {
+            (0, debug_logger_1.debugLog)('Currently installed bundle is valid');
+            writeBundleVerificationLock();
+            return {
+                version: currentBundle.version,
+                nxCloudClient: require(currentBundle.fullPath),
+            };
+        }
+        const { version, url } = verifyBundleResponse.data;
+        (0, debug_logger_1.debugLog)('Currently installed bundle is invalid, downloading version', version, ' from ', url);
+        if (version === 'NX_ENTERPRISE_OUTDATED_IMAGE') {
+            throw new NxCloudEnterpriseOutdatedError(apiUrl);
+        }
+        const fullPath = await downloadAndExtractClientBundle(axios, runnerBundleInstallDirectory, version, url);
+        (0, debug_logger_1.debugLog)('Done: ', fullPath);
+        const nxCloudClient = require(fullPath);
+        if (nxCloudClient.commands === undefined) {
+            throw new NxCloudEnterpriseOutdatedError(apiUrl);
+        }
+        return { version, nxCloudClient };
+    }
+    if (currentBundle === null) {
+        throw new NxCloudClientUnavailableError();
+    }
+    (0, debug_logger_1.debugLog)('Done: ', currentBundle.fullPath);
+    return {
+        version: currentBundle.version,
+        nxCloudClient: require(currentBundle.fullPath),
+    };
+}
+function getBundleInstallDefaultLocation() {
+    // When not in an Nx workspace (no nx.json), avoid creating a .nx folder
+    // in the current directory. Instead, use a temp directory unique to the
+    // NX_CLOUD_API URL so different cloud instances don't conflict.
+    if (!(0, fs_1.existsSync)((0, path_1.join)(workspace_root_1.workspaceRoot, 'nx.json'))) {
+        const apiUrl = process.env.NX_CLOUD_API || 'https://cloud.nx.app';
+        const apiHash = (0, crypto_1.createHash)('sha256')
+            .update(apiUrl)
+            .digest('hex')
+            .slice(0, 16);
+        return (0, path_1.join)((0, os_1.tmpdir)(), 'nx-cloud-client', apiHash);
+    }
+    const legacyPath = (0, path_1.join)(workspace_root_1.workspaceRoot, 'node_modules', '.cache', 'nx', 'cloud');
+    // this legacy path is used when the nx-cloud package is installed.
+    // make sure to reuse it so that we don't `require` different the client bundles
+    if ((0, fs_1.existsSync)(legacyPath)) {
+        return legacyPath;
+    }
+    else {
+        return (0, path_1.join)(cache_directory_1.cacheDir, 'cloud');
+    }
+}
+const runnerBundleInstallDirectory = getBundleInstallDefaultLocation();
+function getLatestInstalledRunnerBundle() {
+    if (!(0, fs_1.existsSync)(runnerBundleInstallDirectory)) {
+        (0, fs_1.mkdirSync)(runnerBundleInstallDirectory, { recursive: true });
+    }
+    try {
+        const installedBundles = (0, fs_1.readdirSync)(runnerBundleInstallDirectory)
+            .filter((potentialDirectory) => {
+            return (0, fs_1.statSync)((0, path_1.join)(runnerBundleInstallDirectory, potentialDirectory)).isDirectory();
+        })
+            .map((fileOrDirectory) => ({
+            version: fileOrDirectory,
+            fullPath: (0, path_1.join)(runnerBundleInstallDirectory, fileOrDirectory),
+        }));
+        if (installedBundles.length === 0) {
+            // No installed bundles
+            return null;
+        }
+        return installedBundles[0];
+    }
+    catch (e) {
+        console.log('Could not read runner bundle path:', e.message);
+        return null;
+    }
+}
+function shouldVerifyInstalledRunnerBundle(currentBundle) {
+    if (process.env.NX_CLOUD_FORCE_REVALIDATE === 'true') {
+        return true;
+    }
+    // No bundle, need to download anyway
+    if (currentBundle != null) {
+        (0, debug_logger_1.debugLog)('A local bundle currently exists: ', currentBundle);
+        const lastVerification = getLatestBundleVerificationTimestamp();
+        // Never been verified, need to verify
+        if (lastVerification != null) {
+            // If last verification was less than 30 minutes ago, return the current installed bundle
+            const THIRTY_MINUTES = 30 * 60 * 1000;
+            if (Date.now() - lastVerification < THIRTY_MINUTES) {
+                (0, debug_logger_1.debugLog)('Last verification was within the past 30 minutes, will not verify this time');
+                return false;
+            }
+            (0, debug_logger_1.debugLog)('Last verification was more than 30 minutes ago, verifying bundle is still valid');
+        }
+    }
+    return true;
+}
+async function verifyCurrentBundle(axios, currentBundle) {
+    return axios.get('/nx-cloud/client/verify', {
+        params: currentBundle
+            ? {
+                version: currentBundle.version,
+                contentHash: getBundleContentHash(currentBundle),
+            }
+            : {},
+    });
+}
+function getLatestBundleVerificationTimestamp() {
+    const lockfilePath = (0, path_1.join)(runnerBundleInstallDirectory, 'verify.lock');
+    if ((0, fs_1.existsSync)(lockfilePath)) {
+        const timestampAsString = (0, fs_1.readFileSync)(lockfilePath, 'utf-8');
+        let timestampAsNumber;
+        try {
+            timestampAsNumber = Number(timestampAsString);
+            return timestampAsNumber;
+        }
+        catch (e) {
+            return null;
+        }
+    }
+    return null;
+}
+function writeBundleVerificationLock() {
+    const lockfilePath = (0, path_1.join)(runnerBundleInstallDirectory, 'verify.lock');
+    (0, fs_1.writeFileSync)(lockfilePath, new Date().getTime().toString(), 'utf-8');
+}
+function getBundleContentHash(bundle) {
+    if (bundle == null) {
+        return null;
+    }
+    return hashDirectory(bundle.fullPath);
+}
+function hashDirectory(dir) {
+    const files = (0, fs_1.readdirSync)(dir).sort();
+    const hashes = files.map((file) => {
+        const filePath = (0, path_1.join)(dir, file);
+        const stat = (0, fs_1.statSync)(filePath);
+        // If the current path is a directory, recursively hash the contents
+        if (stat.isDirectory()) {
+            return hashDirectory(filePath);
+        }
+        // If it's a file, hash the file contents
+        const content = (0, fs_1.readFileSync)(filePath);
+        return (0, crypto_1.createHash)('sha256').update(content).digest('hex');
+    });
+    // Hash the combined hashes of the directory's contents
+    const combinedHashes = hashes.sort().join('');
+    return (0, crypto_1.createHash)('sha256').update(combinedHashes).digest('hex');
+}
+async function downloadAndExtractClientBundle(axios, runnerBundleInstallDirectory, version, url) {
+    let resp;
+    try {
+        resp = await axios.get(url, {
+            responseType: 'stream',
+        });
+    }
+    catch (e) {
+        console.error('Error while updating Nx Cloud client bundle');
+        throw e;
+    }
+    const bundleExtractLocation = (0, path_1.join)(runnerBundleInstallDirectory, version);
+    if (!(0, fs_1.existsSync)(bundleExtractLocation)) {
+        (0, fs_1.mkdirSync)(bundleExtractLocation);
+    }
+    return new Promise((res, rej) => {
+        const extract = tar.extract();
+        extract.on('entry', function (headers, stream, next) {
+            if (headers.type === 'directory') {
+                const directoryPath = (0, path_1.join)(bundleExtractLocation, headers.name);
+                if (!(0, fs_1.existsSync)(directoryPath)) {
+                    (0, fs_1.mkdirSync)(directoryPath, { recursive: true });
+                }
+                next();
+                stream.resume();
+            }
+            else if (headers.type === 'file') {
+                const outputFilePath = (0, path_1.join)(bundleExtractLocation, headers.name);
+                const writeStream = (0, fs_1.createWriteStream)(outputFilePath);
+                stream.pipe(writeStream);
+                // Continue the tar stream after the write stream closes
+                writeStream.on('close', () => {
+                    next();
+                });
+                stream.resume();
+            }
+        });
+        extract.on('error', (e) => {
+            rej(e);
+        });
+        extract.on('finish', function () {
+            removeOldClientBundles(version);
+            writeBundleVerificationLock();
+            res(bundleExtractLocation);
+        });
+        resp.data.pipe((0, zlib_1.createGunzip)()).pipe(extract);
+    });
+}
+function removeOldClientBundles(currentInstallVersion) {
+    const filesAndFolders = (0, fs_1.readdirSync)(runnerBundleInstallDirectory);
+    for (let fileOrFolder of filesAndFolders) {
+        const fileOrFolderPath = (0, path_1.join)(runnerBundleInstallDirectory, fileOrFolder);
+        if (fileOrFolder !== currentInstallVersion) {
+            (0, fs_1.rmSync)(fileOrFolderPath, { recursive: true });
+        }
+    }
+}

package/dist/src/nx-cloud/utilities/axios.d.ts

@@ -0,0 +1,4 @@
+export declare function createApiAxiosInstance(options?: {
+    url?: string;
+    customProxyConfigPath?: string;
+}): any;

package/dist/src/nx-cloud/utilities/axios.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createApiAxiosInstance = createApiAxiosInstance;
+const path_1 = require("path");
+const environment_1 = require("./environment");
+function createApiAxiosInstance(options) {
+    let axiosConfigBuilder = (axiosConfig) => axiosConfig;
+    const baseUrl = process.env.NX_CLOUD_API || options?.url || 'https://cloud.nx.app';
+    if (options?.customProxyConfigPath) {
+        const { nxCloudProxyConfig } = require((0, path_1.join)(process.cwd(), options.customProxyConfigPath));
+        axiosConfigBuilder = nxCloudProxyConfig ?? axiosConfigBuilder;
+    }
+    return require('axios').create(axiosConfigBuilder({
+        baseURL: baseUrl,
+        timeout: environment_1.NX_CLOUD_NO_TIMEOUTS ? environment_1.UNLIMITED_TIMEOUT : 10000,
+    }));
+}

package/dist/src/nx-cloud/utilities/client.d.ts

@@ -0,0 +1,10 @@
+import { CloudTaskRunnerOptions } from '../nx-cloud-tasks-runner-shell';
+export declare class UnknownCommandError extends Error {
+    command: string;
+    availableCommands: string[];
+    constructor(command: string, availableCommands: string[]);
+}
+export declare function getCloudClient(options: CloudTaskRunnerOptions): Promise<{
+    invoke: (command: string, exit?: boolean) => void;
+    availableCommands: string[];
+}>;

package/dist/src/nx-cloud/utilities/client.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnknownCommandError = void 0;
+exports.getCloudClient = getCloudClient;
+const resolution_helpers_1 = require("../resolution-helpers");
+const update_manager_1 = require("../update-manager");
+class UnknownCommandError extends Error {
+    constructor(command, availableCommands) {
+        super(`Unknown Command "${command}"`);
+        this.command = command;
+        this.availableCommands = availableCommands;
+    }
+}
+exports.UnknownCommandError = UnknownCommandError;
+async function getCloudClient(options) {
+    const { nxCloudClient } = await (0, update_manager_1.verifyOrUpdateNxCloudClient)(options);
+    const paths = (0, resolution_helpers_1.findAncestorNodeModules)(__dirname, []);
+    nxCloudClient.configureLightClientRequire()(paths);
+    return {
+        invoke: (command, exit = true) => {
+            if (command in nxCloudClient.commands) {
+                nxCloudClient.commands[command]()
+                    .then(() => {
+                    if (exit) {
+                        process.exit(0);
+                    }
+                })
+                    .catch((e) => {
+                    console.error(e);
+                    if (exit) {
+                        process.exit(1);
+                    }
+                    throw e;
+                });
+            }
+            else {
+                throw new UnknownCommandError(command, Object.keys(nxCloudClient.commands));
+            }
+        },
+        availableCommands: Object.keys(nxCloudClient.commands),
+    };
+}

package/dist/src/nx-cloud/utilities/environment.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NX_CLOUD_NO_TIMEOUTS = exports.ACCESS_TOKEN = exports.UNLIMITED_TIMEOUT = void 0;
+const tslib_1 = require("tslib");
+const dotenv = tslib_1.__importStar(require("dotenv"));
+const fs_1 = require("fs");
+const path_1 = require("path");
+const is_ci_1 = require("../../utils/is-ci");
+const workspace_root_1 = require("../../utils/workspace-root");
+// Set once
+exports.UNLIMITED_TIMEOUT = 9999999;
+process.env.NX_CLOUD_AGENT_TIMEOUT_MS
+    ? Number(process.env.NX_CLOUD_AGENT_TIMEOUT_MS)
+    : 3600000;
+// 60 minutes
+process.env.NX_CLOUD_ORCHESTRATOR_TIMEOUT_MS
+    ? Number(process.env.NX_CLOUD_ORCHESTRATOR_TIMEOUT_MS)
+    : 3600000;
+// 60 minutes
+process.env.NX_CLOUD_DISTRIBUTED_EXECUTION_AGENT_COUNT
+    ? Number(process.env.NX_CLOUD_DISTRIBUTED_EXECUTION_AGENT_COUNT)
+    : null;
+process.env.NX_CLOUD_NUMBER_OF_RETRIES
+    ? Number(process.env.NX_CLOUD_NUMBER_OF_RETRIES)
+    : (0, is_ci_1.isCI)()
+        ? 10
+        : 1;
+loadEnvVars();
+function parseEnv() {
+    try {
+        const envContents = (0, fs_1.readFileSync)((0, path_1.join)(workspace_root_1.workspaceRoot, 'nx-cloud.env'));
+        return dotenv.parse(envContents);
+    }
+    catch (e) {
+        return {};
+    }
+}
+function loadEnvVars() {
+    const parsed = parseEnv();
+    exports.ACCESS_TOKEN =
+        process.env.NX_CLOUD_AUTH_TOKEN ||
+            process.env.NX_CLOUD_ACCESS_TOKEN ||
+            parsed.NX_CLOUD_AUTH_TOKEN ||
+            parsed.NX_CLOUD_ACCESS_TOKEN;
+    exports.NX_CLOUD_NO_TIMEOUTS =
+        process.env.NX_CLOUD_NO_TIMEOUTS === 'true' ||
+            parsed.NX_CLOUD_NO_TIMEOUTS === 'true';
+}

package/dist/src/nx-cloud/utilities/onboarding.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNxCloudOnboardingURLForWelcomeApp = createNxCloudOnboardingURLForWelcomeApp;
+exports.getNxCloudAppOnBoardingUrl = getNxCloudAppOnBoardingUrl;
+exports.readNxCloudToken = readNxCloudToken;
+const is_workspace_claimed_1 = require("./is-workspace-claimed");
+const url_shorten_1 = require("./url-shorten");
+const run_command_1 = require("../../tasks-runner/run-command");
+const nx_json_1 = require("../../generators/utils/nx-json");
+async function createNxCloudOnboardingURLForWelcomeApp(tree, token) {
+    token = token || readNxCloudToken(tree);
+    if (!token) {
+        return 'not-configured';
+    }
+    return (await (0, is_workspace_claimed_1.isWorkspaceClaimed)(token)) ? 'claimed' : 'unclaimed';
+}
+async function getNxCloudAppOnBoardingUrl(token) {
+    if (!token) {
+        return null;
+    }
+    const onboardingUrl = await (0, url_shorten_1.createNxCloudOnboardingURL)('nx-welcome-app', token, undefined, false);
+    return onboardingUrl;
+}
+function readNxCloudToken(tree) {
+    const nxJson = (0, nx_json_1.readNxJson)(tree);
+    const { accessToken, nxCloudId } = (0, run_command_1.getRunnerOptions)('default', nxJson, {}, true);
+    return accessToken || nxCloudId;
+}

package/dist/src/nx-cloud/utilities/url-shorten.d.ts

@@ -0,0 +1,5 @@
+/**
+ * This is currently duplicated in Nx Console. Please let @MaxKless know if you make changes here.
+ */
+export declare function createNxCloudOnboardingURL(onboardingSource: string, accessToken?: string, meta?: string, forceManual?: boolean, forceGithub?: boolean, directory?: string): Promise<string>;
+export declare function getURLifShortenFailed(usesGithub: boolean, githubSlug: string | null, apiUrl: string, source: string, accessToken?: string): string;

package/dist/src/nx-cloud/utilities/url-shorten.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNxCloudOnboardingURL = createNxCloudOnboardingURL;
+exports.getURLifShortenFailed = getURLifShortenFailed;
+const logger_1 = require("../../utils/logger");
+const get_cloud_options_1 = require("./get-cloud-options");
+const git_utils_1 = require("../../utils/git-utils");
+/**
+ * This is currently duplicated in Nx Console. Please let @MaxKless know if you make changes here.
+ */
+async function createNxCloudOnboardingURL(onboardingSource, accessToken, meta, forceManual = false, forceGithub = false, directory) {
+    const remoteInfo = (0, git_utils_1.getVcsRemoteInfo)(directory);
+    const apiUrl = (0, get_cloud_options_1.getCloudUrl)();
+    const installationSupportsGitHub = await getInstallationSupportsGitHub(apiUrl);
+    let usesGithub = false;
+    if (forceGithub) {
+        usesGithub = installationSupportsGitHub;
+    }
+    else if (forceManual) {
+        usesGithub = false;
+    }
+    else {
+        usesGithub =
+            remoteInfo?.domain === 'github.com' && installationSupportsGitHub;
+    }
+    const source = getSource(onboardingSource);
+    try {
+        const response = await require('axios').post(`${apiUrl}/nx-cloud/onboarding`, {
+            type: usesGithub ? 'GITHUB' : 'MANUAL',
+            source,
+            accessToken: usesGithub ? null : accessToken,
+            selectedRepositoryName: remoteInfo?.slug ?? null,
+            repositoryDomain: remoteInfo?.domain ?? null,
+            meta,
+        });
+        if (!response?.data || response.data.message) {
+            throw new Error(response?.data?.message ?? 'Failed to shorten Nx Cloud URL');
+        }
+        return `${apiUrl}/connect/${response.data}`;
+    }
+    catch (e) {
+        logger_1.logger.verbose(`Failed to shorten Nx Cloud URL.
+    ${e}`);
+        return getURLifShortenFailed(usesGithub, usesGithub ? remoteInfo?.slug : null, apiUrl, source, accessToken);
+    }
+}
+function getSource(installationSource) {
+    if (installationSource.includes('nx-init')) {
+        return 'nx-init';
+    }
+    else if (installationSource.includes('nx-connect')) {
+        return 'nx-connect';
+    }
+    else {
+        return installationSource;
+    }
+}
+function getURLifShortenFailed(usesGithub, githubSlug, apiUrl, source, accessToken) {
+    if (usesGithub) {
+        if (githubSlug) {
+            return `${apiUrl}/setup/connect-workspace/github/connect?name=${encodeURIComponent(githubSlug)}&source=${source}`;
+        }
+        else {
+            return `${apiUrl}/setup/connect-workspace/github/select?source=${source}`;
+        }
+    }
+    return `${apiUrl}/setup/connect-workspace/manual?accessToken=${accessToken}&source=${source}`;
+}
+async function getInstallationSupportsGitHub(apiUrl) {
+    try {
+        const response = await require('axios').get(`${apiUrl}/nx-cloud/system/features`);
+        if (!response?.data || response.data.message) {
+            throw new Error(response?.data?.message ?? 'Failed to shorten Nx Cloud URL');
+        }
+        return !!response.data.isGithubIntegrationEnabled;
+    }
+    catch (e) {
+        if (process.env.NX_VERBOSE_LOGGING === 'true') {
+            logger_1.logger.warn(`Failed to access system features. GitHub integration assumed to be disabled.
+    ${e}`);
+        }
+        return false;
+    }
+}

package/dist/src/plugins/js/index.d.ts

@@ -0,0 +1,4 @@
+import { CreateDependencies, CreateNodesV2 } from '../../project-graph/plugins';
+export declare const name = "nx/js/dependencies-and-lockfile";
+export declare const createNodesV2: CreateNodesV2;
+export declare const createDependencies: CreateDependencies;