@ohos-ports/nx 19.8.4-beta.0

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

@@ -0,0 +1,240 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NxCloudClientUnavailableError = exports.NxCloudEnterpriseOutdatedError = void 0;
+exports.verifyOrUpdateNxCloudClient = verifyOrUpdateNxCloudClient;
+const fs_1 = require("fs");
+const zlib_1 = require("zlib");
+const path_1 = require("path");
+const axios_1 = require("./utilities/axios");
+const debug_logger_1 = require("./debug-logger");
+const tar = require("tar-stream");
+const cache_directory_1 = require("../utils/cache-directory");
+const crypto_1 = require("crypto");
+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();
+    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' && options.url) {
+                throw new NxCloudEnterpriseOutdatedError(options.url);
+            }
+            (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(options.url);
+            }
+            const nxCloudClient = require(currentBundle.fullPath);
+            if (nxCloudClient.commands === undefined) {
+                throw new NxCloudEnterpriseOutdatedError(options.url);
+            }
+            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(options.url);
+        }
+        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(options.url);
+        }
+        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),
+    };
+}
+const runnerBundleInstallDirectory = (0, path_1.join)(cache_directory_1.cacheDir, 'cloud');
+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/src/nx-cloud/utilities/axios.d.ts

@@ -0,0 +1,2 @@
+import { CloudTaskRunnerOptions } from '../nx-cloud-tasks-runner-shell';
+export declare function createApiAxiosInstance(options: CloudTaskRunnerOptions): any;

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

@@ -0,0 +1,24 @@
+"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';
+    const accessToken = environment_1.ACCESS_TOKEN ? environment_1.ACCESS_TOKEN : options.accessToken;
+    const nxCloudId = options.nxCloudId;
+    // TODO(lourw): Update message with NxCloudId once it is supported
+    if (!accessToken && !nxCloudId) {
+        throw new Error(`Unable to authenticate. If you are connecting to Nx Cloud locally, set an Nx Cloud ID in your nx.json with "nx connect". If you are in a CI context, please set the NX_CLOUD_ACCESS_TOKEN environment variable or define an access token in your nx.json.`);
+    }
+    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,
+        headers: { authorization: accessToken },
+    }));
+}

package/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) => void;
+    availableCommands: string[];
+}>;

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

@@ -0,0 +1,35 @@
+"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) => {
+            if (command in nxCloudClient.commands) {
+                nxCloudClient.commands[command]()
+                    .then(() => process.exit(0))
+                    .catch((e) => {
+                    console.error(e);
+                    process.exit(1);
+                });
+            }
+            else {
+                throw new UnknownCommandError(command, Object.keys(nxCloudClient.commands));
+            }
+        },
+        availableCommands: Object.keys(nxCloudClient.commands),
+    };
+}

package/src/nx-cloud/utilities/environment.d.ts

@@ -0,0 +1,3 @@
+export declare const UNLIMITED_TIMEOUT = 9999999;
+export declare let ACCESS_TOKEN: any;
+export declare let NX_CLOUD_NO_TIMEOUTS: any;

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

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NX_CLOUD_NO_TIMEOUTS = exports.ACCESS_TOKEN = exports.UNLIMITED_TIMEOUT = void 0;
+const dotenv = 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/src/nx-cloud/utilities/get-cloud-options.d.ts

@@ -0,0 +1,5 @@
+import { CloudTaskRunnerOptions } from '../nx-cloud-tasks-runner-shell';
+export declare function getCloudOptions(directory?: string): CloudTaskRunnerOptions;
+export declare function getCloudUrl(): string;
+export declare function removeTrailingSlash(apiUrl: string): string;
+export declare function isNxCloudId(token: string): boolean;

package/src/nx-cloud/utilities/get-cloud-options.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCloudOptions = getCloudOptions;
+exports.getCloudUrl = getCloudUrl;
+exports.removeTrailingSlash = removeTrailingSlash;
+exports.isNxCloudId = isNxCloudId;
+const nx_json_1 = require("../../config/nx-json");
+const run_command_1 = require("../../tasks-runner/run-command");
+const workspace_root_1 = require("../../utils/workspace-root");
+function getCloudOptions(directory = workspace_root_1.workspaceRoot) {
+    const nxJson = (0, nx_json_1.readNxJson)(directory);
+    // TODO: The default is not always cloud? But it's not handled at the moment
+    return (0, run_command_1.getRunnerOptions)('default', nxJson, {}, true);
+}
+function getCloudUrl() {
+    return removeTrailingSlash(process.env.NX_CLOUD_API || process.env.NRWL_API || `https://cloud.nx.app`);
+}
+function removeTrailingSlash(apiUrl) {
+    return apiUrl[apiUrl.length - 1] === '/' ? apiUrl.slice(0, -1) : apiUrl;
+}
+function isNxCloudId(token) {
+    return token.length === 24;
+}

package/src/nx-cloud/utilities/is-workspace-claimed.d.ts

@@ -0,0 +1 @@
+export declare function isWorkspaceClaimed(accessToken: string): Promise<any>;

package/src/nx-cloud/utilities/is-workspace-claimed.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isWorkspaceClaimed = isWorkspaceClaimed;
+const get_cloud_options_1 = require("./get-cloud-options");
+async function isWorkspaceClaimed(accessToken) {
+    if (!accessToken)
+        return false;
+    const apiUrl = (0, get_cloud_options_1.getCloudUrl)();
+    try {
+        const requestData = (0, get_cloud_options_1.isNxCloudId)(accessToken)
+            ? { nxCloudId: accessToken }
+            : { nxCloudAccessToken: accessToken };
+        const response = await require('axios').post(`${apiUrl}/nx-cloud/is-workspace-claimed`, requestData);
+        if (response.data.message) {
+            return false;
+        }
+        else {
+            return response.data;
+        }
+    }
+    catch (e) {
+        // We want to handle cases the if the request fails for any reason
+        return false;
+    }
+}

package/src/nx-cloud/utilities/onboarding.d.ts

@@ -0,0 +1,5 @@
+import type { Tree } from '../../generators/tree';
+import { NxCloudOnBoardingStatus } from '../models/onboarding-status';
+export declare function createNxCloudOnboardingURLForWelcomeApp(tree: Tree, token?: string): Promise<NxCloudOnBoardingStatus>;
+export declare function getNxCloudAppOnBoardingUrl(token: string): Promise<string>;
+export declare function readNxCloudToken(tree: Tree): any;

package/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);
+    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/src/nx-cloud/utilities/url-shorten.d.ts

@@ -0,0 +1,10 @@
+/**
+ * This is currently duplicated in Nx Console. Please let @MaxKless know if you make changes here.
+ */
+export declare function createNxCloudOnboardingURL(onboardingSource: string, accessToken?: string, usesGithub?: boolean, meta?: string): Promise<string>;
+export declare function repoUsesGithub(github?: boolean, githubSlug?: string, apiUrl?: string): Promise<boolean>;
+export declare function getURLifShortenFailed(usesGithub: boolean, githubSlug: string | null, apiUrl: string, source: string, accessToken?: string): string;
+export declare function getNxCloudVersion(apiUrl: string): Promise<string | null>;
+export declare function removeVersionModifier(versionString: string): string;
+export declare function versionIsValid(version: string): boolean;
+export declare function compareCleanCloudVersions(version1: string, version2: string): number;

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

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNxCloudOnboardingURL = createNxCloudOnboardingURL;
+exports.repoUsesGithub = repoUsesGithub;
+exports.getURLifShortenFailed = getURLifShortenFailed;
+exports.getNxCloudVersion = getNxCloudVersion;
+exports.removeVersionModifier = removeVersionModifier;
+exports.versionIsValid = versionIsValid;
+exports.compareCleanCloudVersions = compareCleanCloudVersions;
+const logger_1 = require("../../utils/logger");
+const git_utils_1 = require("../../utils/git-utils");
+const get_cloud_options_1 = require("./get-cloud-options");
+/**
+ * This is currently duplicated in Nx Console. Please let @MaxKless know if you make changes here.
+ */
+async function createNxCloudOnboardingURL(onboardingSource, accessToken, usesGithub, meta) {
+    const githubSlug = (0, git_utils_1.getGithubSlugOrNull)();
+    const apiUrl = (0, get_cloud_options_1.getCloudUrl)();
+    if (usesGithub === undefined || usesGithub === null) {
+        usesGithub = await repoUsesGithub(undefined, githubSlug, apiUrl);
+    }
+    try {
+        const version = await getNxCloudVersion(apiUrl);
+        if ((version && compareCleanCloudVersions(version, '2406.11.5') < 0) ||
+            !version) {
+            return apiUrl;
+        }
+    }
+    catch (e) {
+        logger_1.logger.verbose(`Failed to get Nx Cloud version.
+    ${e}`);
+        return apiUrl;
+    }
+    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: githubSlug === 'github' ? null : githubSlug,
+            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, githubSlug === 'github' ? null : githubSlug, apiUrl, source, accessToken);
+    }
+}
+async function repoUsesGithub(github, githubSlug, apiUrl) {
+    if (!apiUrl) {
+        apiUrl = (0, get_cloud_options_1.getCloudUrl)();
+    }
+    if (!githubSlug) {
+        githubSlug = (0, git_utils_1.getGithubSlugOrNull)();
+    }
+    const installationSupportsGitHub = await getInstallationSupportsGitHub(apiUrl);
+    return ((!!githubSlug || !!github) &&
+        (apiUrl.includes('cloud.nx.app') ||
+            apiUrl.includes('eu.nx.app') ||
+            installationSupportsGitHub));
+}
+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;
+    }
+}
+async function getNxCloudVersion(apiUrl) {
+    try {
+        const response = await require('axios').get(`${apiUrl}/nx-cloud/system/version`);
+        const version = removeVersionModifier(response.data.version);
+        const isValid = versionIsValid(version);
+        if (!version) {
+            throw new Error('Failed to extract version from response.');
+        }
+        if (!isValid) {
+            throw new Error(`Invalid version format: ${version}`);
+        }
+        return version;
+    }
+    catch (e) {
+        logger_1.logger.verbose(`Failed to get version of Nx Cloud.
+      ${e}`);
+        return null;
+    }
+}
+function removeVersionModifier(versionString) {
+    // Cloud version string is in the format of YYMM.DD.BuildNumber-Modifier
+    return versionString.split(/[\.-]/).slice(0, 3).join('.');
+}
+function versionIsValid(version) {
+    // Updated Regex pattern to require YYMM.DD.BuildNumber format
+    // All parts are required, including the BuildNumber.
+    const pattern = /^\d{4}\.\d{2}\.\d+$/;
+    return pattern.test(version);
+}
+function compareCleanCloudVersions(version1, version2) {
+    const parseVersion = (version) => {
+        // The format we're using is YYMM.DD.BuildNumber
+        const parts = version.split('.').map((part) => parseInt(part, 10));
+        return {
+            yearMonth: parts[0],
+            day: parts[1],
+            buildNumber: parts[2],
+        };
+    };
+    const v1 = parseVersion(version1);
+    const v2 = parseVersion(version2);
+    if (v1.yearMonth !== v2.yearMonth) {
+        return v1.yearMonth > v2.yearMonth ? 1 : -1;
+    }
+    if (v1.day !== v2.day) {
+        return v1.day > v2.day ? 1 : -1;
+    }
+    if (v1.buildNumber !== v2.buildNumber) {
+        return v1.buildNumber > v2.buildNumber ? 1 : -1;
+    }
+    return 0;
+}

package/src/plugins/js/hasher/hasher.d.ts

@@ -0,0 +1,5 @@
+import { ProjectGraphProjectNode } from '../../../config/project-graph';
+import { ProjectRootMappings } from '../../../project-graph/utils/find-project-for-path';
+export declare function hashTsConfig(p: ProjectGraphProjectNode, projectRootMappings: ProjectRootMappings, { selectivelyHashTsConfig }: {
+    selectivelyHashTsConfig: boolean;
+}): string;