@depup/nx 22.5.4-depup.0

package/src/nx-cloud/nx-cloud-tasks-runner-shell.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nxCloudTasksRunnerShell = void 0;
+const default_tasks_runner_1 = require("../tasks-runner/default-tasks-runner");
+const output_1 = require("../utils/output");
+const resolution_helpers_1 = require("./resolution-helpers");
+const update_manager_1 = require("./update-manager");
+const nxCloudTasksRunnerShell = async (tasks, options, context) => {
+    try {
+        const { nxCloudClient, version } = await (0, update_manager_1.verifyOrUpdateNxCloudClient)(options);
+        options.clientVersion = version;
+        const paths = (0, resolution_helpers_1.findAncestorNodeModules)(__dirname, []);
+        nxCloudClient.configureLightClientRequire()(paths);
+        return nxCloudClient.nxCloudTasksRunner(tasks, options, context);
+    }
+    catch (e) {
+        const body = e instanceof update_manager_1.NxCloudEnterpriseOutdatedError
+            ? [
+                'If you are an Nx Enterprise customer, please reach out to your assigned Developer Productivity Engineer.',
+                'If you are NOT an Nx Enterprise customer but are seeing this message, please reach out to cloud-support@nrwl.io.',
+            ]
+            : e instanceof update_manager_1.NxCloudClientUnavailableError
+                ? [
+                    'You might be offline. Nx Cloud will be re-enabled when you are back online.',
+                ]
+                : [];
+        if (e instanceof update_manager_1.NxCloudEnterpriseOutdatedError) {
+            output_1.output.warn({
+                title: e.message,
+                bodyLines: ['Nx Cloud will not be used for this command.', ...body],
+            });
+        }
+        const results = await (0, default_tasks_runner_1.defaultTasksRunner)(tasks, options, context);
+        output_1.output.warn({
+            title: e.message,
+            bodyLines: ['Nx Cloud was not used for this command.', ...body],
+        });
+        return results;
+    }
+};
+exports.nxCloudTasksRunnerShell = nxCloudTasksRunnerShell;

package/src/nx-cloud/resolution-helpers.d.ts

@@ -0,0 +1,2 @@
+export declare function findAncestorNodeModules(startPath: any, collector: any): any;
+//# sourceMappingURL=resolution-helpers.d.ts.map

package/src/nx-cloud/resolution-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolution-helpers.d.ts","sourceRoot":"","sources":["../../../../../packages/nx/src/nx-cloud/resolution-helpers.ts"],"names":[],"mappings":"AAGA,wBAAgB,uBAAuB,CAAC,SAAS,KAAA,EAAE,SAAS,KAAA,OAiB3D"}

package/src/nx-cloud/resolution-helpers.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findAncestorNodeModules = findAncestorNodeModules;
+const fs_1 = require("fs");
+const path_1 = require("path");
+function findAncestorNodeModules(startPath, collector) {
+    let currentPath = (0, path_1.isAbsolute)(startPath) ? startPath : (0, path_1.resolve)(startPath);
+    while (currentPath !== (0, path_1.dirname)(currentPath)) {
+        const potentialNodeModules = (0, path_1.join)(currentPath, 'node_modules');
+        if ((0, fs_1.existsSync)(potentialNodeModules)) {
+            collector.push(potentialNodeModules);
+        }
+        if ((0, fs_1.existsSync)((0, path_1.join)(currentPath, 'nx.json'))) {
+            break;
+        }
+        currentPath = (0, path_1.dirname)(currentPath);
+    }
+    return collector;
+}

package/src/nx-cloud/update-manager.d.ts

@@ -0,0 +1,21 @@
+import type { CloudTaskRunnerOptions } from './nx-cloud-tasks-runner-shell';
+import { TasksRunner } from '../tasks-runner/tasks-runner';
+import { RemoteCacheV2 } from '../tasks-runner/default-tasks-runner';
+export declare class NxCloudEnterpriseOutdatedError extends Error {
+    constructor(url: string);
+}
+export declare class NxCloudClientUnavailableError extends Error {
+    constructor();
+}
+export interface NxCloudClient {
+    configureLightClientRequire: () => (paths: string[]) => void;
+    commands: Record<string, () => Promise<void>>;
+    nxCloudTasksRunner: TasksRunner<CloudTaskRunnerOptions>;
+    getRemoteCache: () => RemoteCacheV2;
+}
+export declare function verifyOrUpdateNxCloudClient(options: CloudTaskRunnerOptions): Promise<{
+    nxCloudClient: NxCloudClient;
+    version: string;
+} | null>;
+export declare function getBundleInstallDefaultLocation(): string;
+//# sourceMappingURL=update-manager.d.ts.map

package/src/nx-cloud/update-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"update-manager.d.ts","sourceRoot":"","sources":["../../../../../packages/nx/src/nx-cloud/update-manager.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAC;AAI5E,OAAO,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAC3D,OAAO,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AAwBrE,qBAAa,8BAA+B,SAAQ,KAAK;gBAC3C,GAAG,EAAE,MAAM;CAGxB;AACD,qBAAa,6BAA8B,SAAQ,KAAK;;CAIvD;AAED,MAAM,WAAW,aAAa;IAC5B,2BAA2B,EAAE,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,IAAI,CAAC;IAC7D,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC;IAC9C,kBAAkB,EAAE,WAAW,CAAC,sBAAsB,CAAC,CAAC;IACxD,cAAc,EAAE,MAAM,aAAa,CAAC;CACrC;AACD,wBAAsB,2BAA2B,CAC/C,OAAO,EAAE,sBAAsB,GAC9B,OAAO,CAAC;IAAE,aAAa,EAAE,aAAa,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAAC,CAyFnE;AAED,wBAAgB,+BAA+B,WAgB9C"}

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

@@ -0,0 +1,253 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NxCloudClientUnavailableError = exports.NxCloudEnterpriseOutdatedError = void 0;
+exports.verifyOrUpdateNxCloudClient = verifyOrUpdateNxCloudClient;
+exports.getBundleInstallDefaultLocation = getBundleInstallDefaultLocation;
+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");
+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();
+    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),
+    };
+}
+function getBundleInstallDefaultLocation() {
+    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/src/nx-cloud/utilities/axios.d.ts

@@ -0,0 +1,3 @@
+import { CloudTaskRunnerOptions } from '../nx-cloud-tasks-runner-shell';
+export declare function createApiAxiosInstance(options: CloudTaskRunnerOptions): any;
+//# sourceMappingURL=axios.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"axios.d.ts","sourceRoot":"","sources":["../../../../../../packages/nx/src/nx-cloud/utilities/axios.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,sBAAsB,EAAE,MAAM,gCAAgC,CAAC;AAExE,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,sBAAsB,OA4BrE"}

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,11 @@
+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[];
+}>;
+//# sourceMappingURL=client.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../../../../packages/nx/src/nx-cloud/utilities/client.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,sBAAsB,EAAE,MAAM,gCAAgC,CAAC;AAExE,qBAAa,mBAAoB,SAAQ,KAAK;IAEnC,OAAO,EAAE,MAAM;IACf,iBAAiB,EAAE,MAAM,EAAE;gBAD3B,OAAO,EAAE,MAAM,EACf,iBAAiB,EAAE,MAAM,EAAE;CAIrC;AAED,wBAAsB,cAAc,CAAC,OAAO,EAAE,sBAAsB;sBAO9C,MAAM;;GAwB3B"}

package/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/src/nx-cloud/utilities/environment.d.ts

@@ -0,0 +1,4 @@
+export declare const UNLIMITED_TIMEOUT = 9999999;
+export declare let ACCESS_TOKEN: any;
+export declare let NX_CLOUD_NO_TIMEOUTS: any;
+//# sourceMappingURL=environment.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"environment.d.ts","sourceRoot":"","sources":["../../../../../../packages/nx/src/nx-cloud/utilities/environment.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,iBAAiB,UAAU,CAAC;AAiBzC,eAAO,IAAI,YAAY,KAAA,CAAC;AACxB,eAAO,IAAI,oBAAoB,KAAA,CAAC"}

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,6 @@
+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;
+//# sourceMappingURL=get-cloud-options.d.ts.map

package/src/nx-cloud/utilities/get-cloud-options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-cloud-options.d.ts","sourceRoot":"","sources":["../../../../../../packages/nx/src/nx-cloud/utilities/get-cloud-options.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,gCAAgC,CAAC;AAKxE,wBAAgB,eAAe,CAC7B,SAAS,SAAgB,GACxB,sBAAsB,CAKxB;AAED,wBAAgB,WAAW,WAI1B;AAED,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,UAEjD;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAElD"}

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,2 @@
+export declare function isWorkspaceClaimed(accessToken: string): Promise<any>;
+//# sourceMappingURL=is-workspace-claimed.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"is-workspace-claimed.d.ts","sourceRoot":"","sources":["../../../../../../packages/nx/src/nx-cloud/utilities/is-workspace-claimed.ts"],"names":[],"mappings":"AAEA,wBAAsB,kBAAkB,CAAC,WAAW,EAAE,MAAM,gBAsB3D"}

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,6 @@
+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;
+//# sourceMappingURL=onboarding.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"onboarding.d.ts","sourceRoot":"","sources":["../../../../../../packages/nx/src/nx-cloud/utilities/onboarding.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,uBAAuB,CAAC;AAClD,OAAO,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAC;AAMtE,wBAAsB,uCAAuC,CAC3D,IAAI,EAAE,IAAI,EACV,KAAK,CAAC,EAAE,MAAM,GACb,OAAO,CAAC,uBAAuB,CAAC,CAMlC;AAED,wBAAsB,0BAA0B,CAAC,KAAK,EAAE,MAAM,mBAW7D;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,IAAI,OAS1C"}

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, 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/src/nx-cloud/utilities/url-shorten.d.ts

@@ -0,0 +1,6 @@
+/**
+ * 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;
+//# sourceMappingURL=url-shorten.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"url-shorten.d.ts","sourceRoot":"","sources":["../../../../../../packages/nx/src/nx-cloud/utilities/url-shorten.ts"],"names":[],"mappings":"AAIA;;GAEG;AACH,wBAAsB,0BAA0B,CAC9C,gBAAgB,EAAE,MAAM,EACxB,WAAW,CAAC,EAAE,MAAM,EACpB,IAAI,CAAC,EAAE,MAAM,EACb,WAAW,UAAQ,EACnB,WAAW,UAAQ,EACnB,SAAS,CAAC,EAAE,MAAM,mBAiDnB;AAcD,wBAAgB,qBAAqB,CACnC,UAAU,EAAE,OAAO,EACnB,UAAU,EAAE,MAAM,GAAG,IAAI,EACzB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,WAAW,CAAC,EAAE,MAAM,UAYrB"}