nx 19.6.0-canary.20240808-333ab77 → 19.6.0-canary.20240813-c72ba9b

package/src/daemon/server/server.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.openSockets = void 0;
 exports.handleResult = handleResult;
 exports.startServer = startServer;
 const fs_1 = require("fs");
@@ -39,13 +40,26 @@ const handle_hash_glob_1 = require("./handle-hash-glob");
 const task_history_1 = require("../message-types/task-history");
 const handle_get_task_history_1 = require("./handle-get-task-history");
 const handle_write_task_runs_to_history_1 = require("./handle-write-task-runs-to-history");
+const force_shutdown_1 = require("../message-types/force-shutdown");
+const handle_force_shutdown_1 = require("./handle-force-shutdown");
+const get_sync_generator_changes_1 = require("../message-types/get-sync-generator-changes");
+const handle_get_sync_generator_changes_1 = require("./handle-get-sync-generator-changes");
+const sync_generators_1 = require("./sync-generators");
+const get_registered_sync_generators_1 = require("../message-types/get-registered-sync-generators");
+const handle_get_registered_sync_generators_1 = require("./handle-get-registered-sync-generators");
+const update_workspace_context_1 = require("../message-types/update-workspace-context");
+const handle_update_workspace_context_1 = require("./handle-update-workspace-context");
+const flush_sync_generator_changes_to_disk_1 = require("../message-types/flush-sync-generator-changes-to-disk");
+const handle_flush_sync_generator_changes_to_disk_1 = require("./handle-flush-sync-generator-changes-to-disk");
 let performanceObserver;
 let workspaceWatcherError;
 let outputsWatcherError;
 global.NX_DAEMON = true;
 let numberOfOpenConnections = 0;
+exports.openSockets = new Set();
 const server = (0, net_1.createServer)(async (socket) => {
     numberOfOpenConnections += 1;
+    exports.openSockets.add(socket);
     logger_1.serverLogger.log(`Established a connection. Number of open connections: ${numberOfOpenConnections}`);
     (0, shutdown_utils_1.resetInactivityTimeout)(handleInactivityTimeout);
     if (!performanceObserver) {
@@ -64,6 +78,7 @@ const server = (0, net_1.createServer)(async (socket) => {
     });
     socket.on('close', () => {
         numberOfOpenConnections -= 1;
+        exports.openSockets.delete(socket);
         logger_1.serverLogger.log(`Closed a connection. Number of open connections: ${numberOfOpenConnections}`);
         (0, file_watcher_sockets_1.removeRegisteredFileWatcherSocket)(socket);
     });
@@ -131,6 +146,21 @@ async function handleMessage(socket, data) {
     else if ((0, task_history_1.isHandleWriteTaskRunsToHistoryMessage)(payload)) {
         await handleResult(socket, 'WRITE_TASK_RUNS_TO_HISTORY', () => (0, handle_write_task_runs_to_history_1.handleWriteTaskRunsToHistory)(payload.taskRuns));
     }
+    else if ((0, force_shutdown_1.isHandleForceShutdownMessage)(payload)) {
+        await handleResult(socket, 'FORCE_SHUTDOWN', () => (0, handle_force_shutdown_1.handleForceShutdown)(server));
+    }
+    else if ((0, get_sync_generator_changes_1.isHandleGetSyncGeneratorChangesMessage)(payload)) {
+        await handleResult(socket, get_sync_generator_changes_1.GET_SYNC_GENERATOR_CHANGES, () => (0, handle_get_sync_generator_changes_1.handleGetSyncGeneratorChanges)(payload.generators));
+    }
+    else if ((0, flush_sync_generator_changes_to_disk_1.isHandleFlushSyncGeneratorChangesToDiskMessage)(payload)) {
+        await handleResult(socket, flush_sync_generator_changes_to_disk_1.FLUSH_SYNC_GENERATOR_CHANGES_TO_DISK, () => (0, handle_flush_sync_generator_changes_to_disk_1.handleFlushSyncGeneratorChangesToDisk)(payload.generators));
+    }
+    else if ((0, get_registered_sync_generators_1.isHandleGetRegisteredSyncGeneratorsMessage)(payload)) {
+        await handleResult(socket, get_registered_sync_generators_1.GET_REGISTERED_SYNC_GENERATORS, () => (0, handle_get_registered_sync_generators_1.handleGetRegisteredSyncGenerators)());
+    }
+    else if ((0, update_workspace_context_1.isHandleUpdateWorkspaceContextMessage)(payload)) {
+        await handleResult(socket, update_workspace_context_1.UPDATE_WORKSPACE_CONTEXT, () => (0, handle_update_workspace_context_1.handleUpdateWorkspaceContext)(payload.createdFiles, payload.updatedFiles, payload.deletedFiles));
+    }
     else {
         await (0, shutdown_utils_1.respondWithErrorAndExit)(socket, `Invalid payload from the client`, new Error(`Unsupported payload sent to daemon server: ${unparsedPayload}`));
     }
@@ -157,6 +187,7 @@ function handleInactivityTimeout() {
         (0, shutdown_utils_1.handleServerProcessTermination)({
             server,
             reason: `${shutdown_utils_1.SERVER_INACTIVITY_TIMEOUT_MS}ms of inactivity`,
+            sockets: exports.openSockets,
         });
     }
 }
@@ -165,14 +196,17 @@ function registerProcessTerminationListeners() {
         .on('SIGINT', () => (0, shutdown_utils_1.handleServerProcessTermination)({
         server,
         reason: 'received process SIGINT',
+        sockets: exports.openSockets,
     }))
         .on('SIGTERM', () => (0, shutdown_utils_1.handleServerProcessTermination)({
         server,
         reason: 'received process SIGTERM',
+        sockets: exports.openSockets,
     }))
         .on('SIGHUP', () => (0, shutdown_utils_1.handleServerProcessTermination)({
         server,
         reason: 'received process SIGHUP',
+        sockets: exports.openSockets,
     }));
 }
 let existingLockHash;
@@ -235,6 +269,7 @@ const handleWorkspaceChanges = async (err, changeEvents) => {
             await (0, shutdown_utils_1.handleServerProcessTermination)({
                 server,
                 reason: outdatedReason,
+                sockets: exports.openSockets,
             });
             return;
         }
@@ -325,6 +360,10 @@ async function startServer() {
                     if (!(0, shutdown_utils_1.getOutputWatcherInstance)()) {
                         (0, shutdown_utils_1.storeOutputWatcherInstance)(await (0, watcher_1.watchOutputFiles)(handleOutputsChanges));
                     }
+                    // listen for project graph recomputation events to collect and schedule sync generators
+                    (0, project_graph_incremental_recomputation_1.registerProjectGraphRecomputationListener)(sync_generators_1.collectAndScheduleSyncGenerators);
+                    // trigger an initial project graph recomputation
+                    (0, project_graph_incremental_recomputation_1.addUpdatedAndDeletedFiles)([], [], []);
                     return resolve(server);
                 }
                 catch (err) {

package/src/daemon/server/shutdown-utils.d.ts

@@ -8,8 +8,9 @@ export declare function getOutputWatcherInstance(): Watcher;
 interface HandleServerProcessTerminationParams {
     server: Server;
     reason: string;
+    sockets: Iterable<Socket>;
 }
-export declare function handleServerProcessTermination({ server, reason, }: HandleServerProcessTerminationParams): Promise<void>;
+export declare function handleServerProcessTermination({ server, reason, sockets, }: HandleServerProcessTerminationParams): Promise<void>;
 export declare function resetInactivityTimeout(cb: () => void): void;
 export declare function respondToClient(socket: Socket, response: string, description: string): Promise<unknown>;
 export declare function respondWithErrorAndExit(socket: Socket, description: string, error: Error): Promise<void>;

package/src/daemon/server/shutdown-utils.js

@@ -30,11 +30,16 @@ function storeOutputWatcherInstance(instance) {
 function getOutputWatcherInstance() {
     return outputWatcherInstance;
 }
-async function handleServerProcessTermination({ server, reason, }) {
+async function handleServerProcessTermination({ server, reason, sockets, }) {
     try {
-        server.close();
-        (0, cache_1.deleteDaemonJsonProcessCache)();
-        (0, plugins_1.cleanupPlugins)();
+        await new Promise((res) => {
+            server.close(() => {
+                res(null);
+            });
+            for (const socket of sockets) {
+                socket.destroy();
+            }
+        });
         if (watcherInstance) {
             await watcherInstance.stop();
             logger_1.serverLogger.watcherLog(`Stopping the watcher for ${workspace_root_1.workspaceRoot} (sources)`);
@@ -43,6 +48,8 @@ async function handleServerProcessTermination({ server, reason, }) {
             await outputWatcherInstance.stop();
             logger_1.serverLogger.watcherLog(`Stopping the watcher for ${workspace_root_1.workspaceRoot} (outputs)`);
         }
+        (0, cache_1.deleteDaemonJsonProcessCache)();
+        (0, plugins_1.cleanupPlugins)();
         logger_1.serverLogger.log(`Server stopped because: "${reason}"`);
     }
     finally {

package/src/daemon/server/sync-generators.d.ts

@@ -0,0 +1,6 @@
+import type { ProjectGraph } from '../../config/project-graph';
+import { type SyncGeneratorChangesResult } from '../../utils/sync-generators';
+export declare function getCachedSyncGeneratorChanges(generators: string[]): Promise<SyncGeneratorChangesResult[]>;
+export declare function flushSyncGeneratorChangesToDisk(generators: string[]): Promise<void>;
+export declare function collectAndScheduleSyncGenerators(projectGraph: ProjectGraph): void;
+export declare function getCachedRegisteredSyncGenerators(): Promise<string[]>;

package/src/daemon/server/sync-generators.js

@@ -0,0 +1,202 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCachedSyncGeneratorChanges = getCachedSyncGeneratorChanges;
+exports.flushSyncGeneratorChangesToDisk = flushSyncGeneratorChangesToDisk;
+exports.collectAndScheduleSyncGenerators = collectAndScheduleSyncGenerators;
+exports.getCachedRegisteredSyncGenerators = getCachedRegisteredSyncGenerators;
+const nx_json_1 = require("../../config/nx-json");
+const tree_1 = require("../../generators/tree");
+const file_hasher_1 = require("../../hasher/file-hasher");
+const project_graph_1 = require("../../project-graph/project-graph");
+const sync_generators_1 = require("../../utils/sync-generators");
+const workspace_root_1 = require("../../utils/workspace-root");
+const logger_1 = require("./logger");
+const project_graph_incremental_recomputation_1 = require("./project-graph-incremental-recomputation");
+const syncGeneratorsCacheResultPromises = new Map();
+let registeredTaskSyncGenerators = new Set();
+let registeredGlobalSyncGenerators = new Set();
+const scheduledGenerators = new Set();
+let waitPeriod = 100;
+let registeredSyncGenerators;
+let scheduledTimeoutId;
+let storedProjectGraphHash;
+let storedNxJsonHash;
+const log = (...messageParts) => {
+    logger_1.serverLogger.log('[SYNC]:', ...messageParts);
+};
+// TODO(leo): check conflicts and reuse the Tree where possible
+async function getCachedSyncGeneratorChanges(generators) {
+    try {
+        log('get sync generators changes on demand', generators);
+        // this is invoked imperatively, so we clear any scheduled run
+        if (scheduledTimeoutId) {
+            log('clearing scheduled run');
+            clearTimeout(scheduledTimeoutId);
+            scheduledTimeoutId = undefined;
+        }
+        // reset the wait time
+        waitPeriod = 100;
+        let projects;
+        let errored = false;
+        const getProjectsConfigurations = async () => {
+            if (projects || errored) {
+                return projects;
+            }
+            const { projectGraph, error } = await (0, project_graph_incremental_recomputation_1.getCachedSerializedProjectGraphPromise)();
+            projects = projectGraph
+                ? (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph).projects
+                : null;
+            errored = error !== undefined;
+            return projects;
+        };
+        return (await Promise.all(generators.map(async (generator) => {
+            if (scheduledGenerators.has(generator) ||
+                !syncGeneratorsCacheResultPromises.has(generator)) {
+                // it's scheduled to run (there are pending changes to process) or
+                // it's not scheduled and there's no cached result, so run it
+                const projects = await getProjectsConfigurations();
+                if (projects) {
+                    log(generator, 'already scheduled or not cached, running it now');
+                    runGenerator(generator, projects);
+                }
+                else {
+                    log(generator, 'already scheduled or not cached, project graph errored');
+                    /**
+                     * This should never happen. This is invoked imperatively, and by
+                     * the time it is invoked, the project graph would have already
+                     * been requested. If it errored, it would have been reported and
+                     * this wouldn't have been invoked. We handle it just in case.
+                     *
+                     * Since the project graph would be reported by the relevant
+                     * handlers separately, we just ignore the error, don't cache
+                     * any result and return an empty result, the next time this is
+                     * invoked the process will repeat until it eventually recovers
+                     * when the project graph is fixed.
+                     */
+                    return Promise.resolve({ changes: [], generatorName: generator });
+                }
+            }
+            else {
+                log(generator, 'not scheduled and has cached result, returning cached result');
+            }
+            return syncGeneratorsCacheResultPromises.get(generator);
+        }))).flat();
+    }
+    catch (e) {
+        console.error(e);
+        syncGeneratorsCacheResultPromises.clear();
+        return [];
+    }
+}
+async function flushSyncGeneratorChangesToDisk(generators) {
+    log('flush sync generators changes', generators);
+    const results = await getCachedSyncGeneratorChanges(generators);
+    for (const generator of generators) {
+        syncGeneratorsCacheResultPromises.delete(generator);
+    }
+    await (0, sync_generators_1.flushSyncGeneratorChanges)(results);
+}
+function collectAndScheduleSyncGenerators(projectGraph) {
+    if (!projectGraph) {
+        // If the project graph is not available, we can't collect and schedule
+        // sync generators. The project graph error will be reported separately.
+        return;
+    }
+    log('collect registered sync generators');
+    collectAllRegisteredSyncGenerators(projectGraph);
+    // a change imply we need to re-run all the generators
+    // make sure to schedule all the collected generators
+    scheduledGenerators.clear();
+    for (const generator of registeredSyncGenerators) {
+        scheduledGenerators.add(generator);
+    }
+    log('scheduling:', [...scheduledGenerators]);
+    if (scheduledTimeoutId) {
+        // we have a scheduled run already, so we don't need to do anything
+        return;
+    }
+    scheduledTimeoutId = setTimeout(async () => {
+        scheduledTimeoutId = undefined;
+        if (waitPeriod < 4000) {
+            waitPeriod = waitPeriod * 2;
+        }
+        if (scheduledGenerators.size === 0) {
+            // no generators to run
+            return;
+        }
+        const { projects } = (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph);
+        for (const generator of scheduledGenerators) {
+            runGenerator(generator, projects);
+        }
+        await Promise.all(syncGeneratorsCacheResultPromises.values());
+    }, waitPeriod);
+}
+async function getCachedRegisteredSyncGenerators() {
+    log('get registered sync generators');
+    if (!registeredSyncGenerators) {
+        log('no registered sync generators, collecting them');
+        const { projectGraph } = await (0, project_graph_incremental_recomputation_1.getCachedSerializedProjectGraphPromise)();
+        collectAllRegisteredSyncGenerators(projectGraph);
+    }
+    else {
+        log('registered sync generators already collected, returning them');
+    }
+    return [...registeredSyncGenerators];
+}
+function collectAllRegisteredSyncGenerators(projectGraph) {
+    const projectGraphHash = hashProjectGraph(projectGraph);
+    if (storedProjectGraphHash !== projectGraphHash) {
+        storedProjectGraphHash = projectGraphHash;
+        registeredTaskSyncGenerators =
+            (0, sync_generators_1.collectRegisteredTaskSyncGenerators)(projectGraph);
+    }
+    else {
+        log('project graph hash is the same, not collecting task sync generators');
+    }
+    const nxJson = (0, nx_json_1.readNxJson)();
+    const nxJsonHash = (0, file_hasher_1.hashArray)(nxJson.sync?.globalGenerators?.sort() ?? []);
+    if (storedNxJsonHash !== nxJsonHash) {
+        storedNxJsonHash = nxJsonHash;
+        registeredGlobalSyncGenerators =
+            (0, sync_generators_1.collectRegisteredGlobalSyncGenerators)(nxJson);
+    }
+    else {
+        log('nx.json hash is the same, not collecting global sync generators');
+    }
+    const generators = new Set([
+        ...registeredTaskSyncGenerators,
+        ...registeredGlobalSyncGenerators,
+    ]);
+    if (!registeredSyncGenerators) {
+        registeredSyncGenerators = generators;
+        return;
+    }
+    for (const generator of registeredSyncGenerators) {
+        if (!generators.has(generator)) {
+            registeredSyncGenerators.delete(generator);
+            syncGeneratorsCacheResultPromises.delete(generator);
+        }
+    }
+    for (const generator of generators) {
+        if (!registeredSyncGenerators.has(generator)) {
+            registeredSyncGenerators.add(generator);
+        }
+    }
+}
+function runGenerator(generator, projects) {
+    log('running scheduled generator', generator);
+    // remove it from the scheduled set
+    scheduledGenerators.delete(generator);
+    const tree = new tree_1.FsTree(workspace_root_1.workspaceRoot, false, `running sync generator ${generator}`);
+    // run the generator and cache the result
+    syncGeneratorsCacheResultPromises.set(generator, (0, sync_generators_1.runSyncGenerator)(tree, generator, projects).then((result) => {
+        log(generator, 'changes:', result.changes.map((c) => c.path).join(', '));
+        return result;
+    }));
+}
+function hashProjectGraph(projectGraph) {
+    const stringifiedProjects = Object.entries(projectGraph.nodes)
+        .sort(([projectNameA], [projectNameB]) => projectNameA.localeCompare(projectNameB))
+        .map(([projectName, projectConfig]) => `${projectName}:${JSON.stringify(projectConfig)}`);
+    return (0, file_hasher_1.hashArray)(stringifiedProjects);
+}

package/src/daemon/server/watcher.js

@@ -10,6 +10,7 @@ const shutdown_utils_1 = require("./shutdown-utils");
 const path_2 = require("../../utils/path");
 const ignore_1 = require("../../utils/ignore");
 const cache_1 = require("../cache");
+const server_1 = require("./server");
 const ALWAYS_IGNORE = [
     ...(0, ignore_1.getAlwaysIgnore)(workspace_root_1.workspaceRoot),
     (0, socket_utils_1.getFullOsSocketPath)(),
@@ -28,6 +29,7 @@ async function watchWorkspace(server, cb) {
                 (0, shutdown_utils_1.handleServerProcessTermination)({
                     server,
                     reason: 'this process is no longer the current daemon (native)',
+                    sockets: server_1.openSockets,
                 });
             }
             if (event.path.endsWith('.gitignore') || event.path === '.nxignore') {
@@ -35,6 +37,7 @@ async function watchWorkspace(server, cb) {
                 (0, shutdown_utils_1.handleServerProcessTermination)({
                     server,
                     reason: 'Stopping the daemon the set of ignored files changed (native)',
+                    sockets: server_1.openSockets,
                 });
             }
         }

package/src/daemon/socket-utils.js

@@ -15,20 +15,33 @@ exports.isWindows = (0, os_1.platform)() === 'win32';
  * See https://nodejs.org/dist/latest-v14.x/docs/api/net.html#net_identifying_paths_for_ipc_connections for a full breakdown
  * of OS differences between Unix domain sockets and named pipes.
  */
-const getFullOsSocketPath = () => exports.isWindows
-    ? '\\\\.\\pipe\\nx\\' + (0, path_1.resolve)((0, tmp_dir_1.getDaemonSocketDir)())
-    : (0, path_1.resolve)((0, tmp_dir_1.getDaemonSocketDir)());
+const getFullOsSocketPath = () => {
+    const path = (0, path_1.resolve)((0, tmp_dir_1.getDaemonSocketDir)());
+    assertValidSocketPath(path);
+    return exports.isWindows ? '\\\\.\\pipe\\nx\\' + path : path;
+};
 exports.getFullOsSocketPath = getFullOsSocketPath;
 const getForkedProcessOsSocketPath = (id) => {
     let path = (0, path_1.resolve)((0, path_1.join)((0, tmp_dir_1.getSocketDir)(), 'fp' + id + '.sock'));
-    return exports.isWindows ? '\\\\.\\pipe\\nx\\' + (0, path_1.resolve)(path) : (0, path_1.resolve)(path);
+    assertValidSocketPath(path);
+    return exports.isWindows ? '\\\\.\\pipe\\nx\\' + path : path;
 };
 exports.getForkedProcessOsSocketPath = getForkedProcessOsSocketPath;
 const getPluginOsSocketPath = (id) => {
     let path = (0, path_1.resolve)((0, path_1.join)((0, tmp_dir_1.getSocketDir)(true), 'plugin' + id + '.sock'));
-    return exports.isWindows ? '\\\\.\\pipe\\nx\\' + (0, path_1.resolve)(path) : (0, path_1.resolve)(path);
+    assertValidSocketPath(path);
+    return exports.isWindows ? '\\\\.\\pipe\\nx\\' + path : path;
 };
 exports.getPluginOsSocketPath = getPluginOsSocketPath;
+function assertValidSocketPath(path) {
+    if (path.length > 95) {
+        throw new Error([
+            'Attempted to open socket that exceeds the maximum socket length.',
+            '',
+            `Set NX_SOCKET_DIR to a shorter path (e.g. ${exports.isWindows ? '%TMP%/nx-tmp' : '/tmp/nx-tmp'}) to avoid this issue.`,
+        ].join('\n'));
+    }
+}
 function killSocketOrPath() {
     try {
         (0, fs_1.unlinkSync)((0, exports.getFullOsSocketPath)());

package/src/daemon/tmp-dir.js

@@ -53,7 +53,8 @@ function socketDirName() {
  */
 function getSocketDir(alreadyUnique = false) {
     try {
-        const dir = process.env.NX_DAEMON_SOCKET_DIR ??
+        const dir = process.env.NX_SOCKET_DIR ??
+            process.env.NX_DAEMON_SOCKET_DIR ??
             (alreadyUnique ? tmp_1.tmpdir : socketDirName());
         (0, fs_extra_1.ensureDirSync)(dir);
         return dir;

package/src/nx-cloud/generators/connect-to-nx-cloud/connect-to-nx-cloud.js

@@ -94,7 +94,7 @@ function addNxCloudOptionsToNxJson(tree, token, directory = '') {
         });
     }
 }
-function addNxCloudIdToNxJson(tree, nxCloudId, directory = tree.root) {
+function addNxCloudIdToNxJson(tree, nxCloudId, directory = '') {
     const nxJsonPath = (0, path_1.join)(directory, 'nx.json');
     if (tree.exists(nxJsonPath)) {
         (0, json_1.updateJson)(tree, (0, path_1.join)(directory, 'nx.json'), (nxJson) => {

package/src/nx-cloud/models/onboarding-status.d.ts

@@ -0,0 +1 @@
+export type NxCloudOnBoardingStatus = 'claimed' | 'unclaimed' | 'not-configured';

package/src/nx-cloud/models/onboarding-status.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

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

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

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isWorkspaceClaimed = isWorkspaceClaimed;
+const get_cloud_options_1 = require("./get-cloud-options");
+async function isWorkspaceClaimed(nxCloudAccessToken) {
+    if (!nxCloudAccessToken)
+        return false;
+    const apiUrl = (0, get_cloud_options_1.getCloudUrl)();
+    try {
+        const response = await require('axios').post(`${apiUrl}/nx-cloud/is-workspace-claimed`, {
+            nxCloudAccessToken,
+        });
+        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 devkit_exports_1 = require("../../devkit-exports");
+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");
+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, devkit_exports_1.readNxJson)(tree);
+    const { accessToken } = (0, run_command_1.getRunnerOptions)('default', nxJson, {}, true);
+    return accessToken;
+}

package/src/project-graph/plugins/internal-api.js

@@ -13,7 +13,6 @@ const loader_1 = require("./loader");
 const utils_1 = require("./utils");
 const error_types_1 = require("../error-types");
 const native_1 = require("../../native");
-const os_1 = require("os");
 class LoadedNxPlugin {
     constructor(plugin, pluginDefinition) {
         this.name = plugin.name;
@@ -72,12 +71,24 @@ exports.LoadedNxPlugin = LoadedNxPlugin;
 // Allows loaded plugins to not be reloaded when
 // referenced multiple times.
 exports.nxPluginCache = new Map();
+function isIsolationEnabled() {
+    // Explicitly enabled, regardless of further conditions
+    if (process.env.NX_ISOLATE_PLUGINS === 'true') {
+        return true;
+    }
+    if (
+    // Explicitly disabled
+    process.env.NX_ISOLATE_PLUGINS === 'false' ||
+        // Isolation is disabled on WASM builds currently.
+        native_1.IS_WASM) {
+        return false;
+    }
+    // Default value
+    return true;
+}
 async function loadNxPlugins(plugins, root = workspace_root_1.workspaceRoot) {
     performance.mark('loadNxPlugins:start');
-    const loadingMethod = process.env.NX_ISOLATE_PLUGINS === 'true' ||
-        (!native_1.IS_WASM &&
-            (0, os_1.platform)() !== 'win32' &&
-            process.env.NX_ISOLATE_PLUGINS !== 'false')
+    const loadingMethod = isIsolationEnabled()
         ? isolation_1.loadNxPluginInIsolation
         : loader_1.loadNxPlugin;
     plugins = await normalizePlugins(plugins, root);

package/src/project-graph/plugins/isolation/messaging.d.ts

@@ -106,7 +106,11 @@ export interface PluginWorkerProcessProjectGraphResult {
         tx: string;
     };
 }
-export type PluginWorkerMessage = PluginWorkerLoadMessage | PluginWorkerCreateNodesMessage | PluginCreateDependenciesMessage | PluginWorkerProcessProjectGraphMessage | PluginCreateMetadataMessage;
+export interface PluginWorkerShutdownMessage {
+    type: 'shutdown';
+    payload: {};
+}
+export type PluginWorkerMessage = PluginWorkerLoadMessage | PluginWorkerShutdownMessage | PluginWorkerCreateNodesMessage | PluginCreateDependenciesMessage | PluginWorkerProcessProjectGraphMessage | PluginCreateMetadataMessage;
 export type PluginWorkerResult = PluginWorkerLoadResult | PluginWorkerCreateNodesResult | PluginCreateDependenciesResult | PluginWorkerProcessProjectGraphResult | PluginCreateMetadataResult;
 export declare function isPluginWorkerMessage(message: Serializable): message is PluginWorkerMessage;
 export declare function isPluginWorkerResult(message: Serializable): message is PluginWorkerResult;

package/src/project-graph/plugins/isolation/messaging.js

@@ -14,6 +14,7 @@ function isPluginWorkerMessage(message) {
             'createDependencies',
             'processProjectGraph',
             'createMetadata',
+            'shutdown',
         ].includes(message.type));
 }
 function isPluginWorkerResult(message) {

package/src/project-graph/plugins/isolation/plugin-pool.js

@@ -29,8 +29,8 @@ async function loadRemoteNxPlugin(plugin, root) {
     const exitHandler = createWorkerExitHandler(worker, pendingPromises);
     const cleanupFunction = () => {
         worker.off('exit', exitHandler);
+        shutdownPluginWorker(socket);
         socket.destroy();
-        shutdownPluginWorker(worker);
         nxPluginWorkerCache.delete(cacheKey);
     };
     cleanupFunctions.add(cleanupFunction);
@@ -55,11 +55,8 @@ async function loadRemoteNxPlugin(plugin, root) {
     nxPluginWorkerCache.set(cacheKey, pluginPromise);
     return [pluginPromise, cleanupFunction];
 }
-function shutdownPluginWorker(worker) {
-    // Clears the plugin cache so no refs to the workers are held
-    internal_api_1.nxPluginCache.clear();
-    // logger.verbose(`[plugin-pool] starting worker shutdown`);
-    worker.kill('SIGINT');
+function shutdownPluginWorker(socket) {
+    (0, messaging_1.sendMessageOverSocket)(socket, { type: 'shutdown', payload: {} });
 }
 /**
  * Creates a message handler for the given worker.
@@ -200,6 +197,7 @@ function createWorkerExitHandler(worker, pendingPromises) {
 }
 let cleanedUp = false;
 const exitHandler = () => {
+    internal_api_1.nxPluginCache.clear();
     for (const fn of cleanupFunctions) {
         fn();
     }

package/src/project-graph/plugins/isolation/plugin-worker.js

@@ -49,6 +49,21 @@ const server = (0, net_1.createServer)((socket) => {
                     };
                 }
             },
+            shutdown: async () => {
+                // Stops accepting new connections, but existing connections are
+                // not closed immediately.
+                server.close(() => {
+                    try {
+                        (0, fs_1.unlinkSync)(socketPath);
+                    }
+                    catch (e) { }
+                    process.exit(0);
+                });
+                // Closes existing connection.
+                socket.end();
+                // Destroys the socket once it's fully closed.
+                socket.destroySoon();
+            },
             createNodes: async ({ configFiles, context, tx }) => {
                 try {
                     const result = await plugin.createNodes[1](configFiles, context);