nx 19.4.0-beta.0 → 19.4.0-beta.2

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

@@ -1,16 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.shortenedCloudUrl = void 0;
+exports.repoUsesGithub = exports.shortenedCloudUrl = void 0;
 const devkit_exports_1 = require("../../devkit-exports");
 const git_utils_1 = require("../../utils/git-utils");
-async function shortenedCloudUrl(installationSource, accessToken, github) {
+const semver_1 = require("semver");
+async function shortenedCloudUrl(installationSource, accessToken, usesGithub) {
     const githubSlug = (0, git_utils_1.getGithubSlugOrNull)();
     const apiUrl = removeTrailingSlash(process.env.NX_CLOUD_API || process.env.NRWL_API || `https://cloud.nx.app`);
-    const installationSupportsGitHub = await getInstallationSupportsGitHub(apiUrl);
-    const usesGithub = (githubSlug || github) &&
-        (apiUrl.includes('cloud.nx.app') ||
-            apiUrl.includes('eu.nx.app') ||
-            installationSupportsGitHub);
+    const version = await getNxCloudVersion(apiUrl);
+    if (version && (0, semver_1.lt)(truncateToSemver(version), '2406.11.5')) {
+        return apiUrl;
+    }
     const source = getSource(installationSource);
     try {
         const response = await require('axios').post(`${apiUrl}/nx-cloud/onboarding`, {
@@ -27,10 +27,20 @@ async function shortenedCloudUrl(installationSource, accessToken, github) {
     catch (e) {
         devkit_exports_1.logger.verbose(`Failed to shorten Nx Cloud URL.
     ${e}`);
-        return getURLifShortenFailed(usesGithub, githubSlug, apiUrl, accessToken, source);
+        return getURLifShortenFailed(usesGithub, githubSlug, apiUrl, source, accessToken);
     }
 }
 exports.shortenedCloudUrl = shortenedCloudUrl;
+async function repoUsesGithub(github) {
+    const githubSlug = (0, git_utils_1.getGithubSlugOrNull)();
+    const apiUrl = removeTrailingSlash(process.env.NX_CLOUD_API || process.env.NRWL_API || `https://cloud.nx.app`);
+    const installationSupportsGitHub = await getInstallationSupportsGitHub(apiUrl);
+    return ((githubSlug || github) &&
+        (apiUrl.includes('cloud.nx.app') ||
+            apiUrl.includes('eu.nx.app') ||
+            installationSupportsGitHub));
+}
+exports.repoUsesGithub = repoUsesGithub;
 function removeTrailingSlash(apiUrl) {
     return apiUrl[apiUrl.length - 1] === '/' ? apiUrl.slice(0, -1) : apiUrl;
 }
@@ -48,13 +58,13 @@ function getSource(installationSource) {
         return 'other';
     }
 }
-function getURLifShortenFailed(usesGithub, githubSlug, apiUrl, accessToken, source) {
+function getURLifShortenFailed(usesGithub, githubSlug, apiUrl, source, accessToken) {
     if (usesGithub) {
         if (githubSlug) {
-            return `${apiUrl}/setup/connect-workspace/vcs?provider=GITHUB&selectedRepositoryName=${encodeURIComponent(githubSlug)}&source=${source}`;
+            return `${apiUrl}/setup/connect-workspace/github/connect?name=${encodeURIComponent(githubSlug)}&source=${source}`;
         }
         else {
-            return `${apiUrl}/setup/connect-workspace/vcs?provider=GITHUB&source=${source}`;
+            return `${apiUrl}/setup/connect-workspace/github/select&source=${source}`;
         }
     }
     return `${apiUrl}/setup/connect-workspace/manual?accessToken=${accessToken}&source=${source}`;
@@ -75,3 +85,29 @@ async function getInstallationSupportsGitHub(apiUrl) {
         return false;
     }
 }
+async function getNxCloudVersion(apiUrl) {
+    try {
+        const response = await require('axios').get(`${apiUrl}/version`, {
+            responseType: 'document',
+        });
+        const version = extractVersion(response.data);
+        if (!version) {
+            throw new Error('Failed to extract version from response.');
+        }
+        return version;
+    }
+    catch (e) {
+        devkit_exports_1.logger.verbose(`Failed to get version of Nx Cloud.
+      ${e}`);
+    }
+}
+function extractVersion(htmlString) {
+    // The pattern assumes 'Version' is inside an h1 tag and the version number is the next span's content
+    const regex = /<h1[^>]*>Version<\/h1>\s*<div[^>]*><div[^>]*><div[^>]*><span[^>]*>([^<]+)<\/span>/;
+    const match = htmlString.match(regex);
+    return match ? match[1].trim() : null;
+}
+function truncateToSemver(versionString) {
+    // version may be something like 2406.13.5.hotfix2
+    return versionString.split(/[\.-]/).slice(0, 3).join('.');
+}

package/src/plugins/package-json-workspaces/create-nodes.js

@@ -73,20 +73,25 @@ function buildProjectConfigurationFromPackageJson(packageJson, workspaceRoot, pa
         throw new Error('Nx requires the root package.json to specify a name if it is being used as an Nx project.');
     }
     let name = packageJson.name ?? (0, to_project_name_1.toProjectName)(normalizedPath);
-    const projectType = nxJson?.workspaceLayout?.appsDir != nxJson?.workspaceLayout?.libsDir &&
-        nxJson?.workspaceLayout?.appsDir &&
-        projectRoot.startsWith(nxJson.workspaceLayout.appsDir)
-        ? 'application'
-        : 'library';
-    return {
+    const projectConfiguration = {
         root: projectRoot,
         sourceRoot: projectRoot,
         name,
-        projectType,
         ...packageJson.nx,
         targets: (0, package_json_1.readTargetsFromPackageJson)(packageJson),
+        tags: (0, package_json_1.getTagsFromPackageJson)(packageJson),
         metadata: (0, package_json_1.getMetadataFromPackageJson)(packageJson),
     };
+    if (nxJson?.workspaceLayout?.appsDir != nxJson?.workspaceLayout?.libsDir &&
+        nxJson?.workspaceLayout?.appsDir &&
+        projectRoot.startsWith(nxJson.workspaceLayout.appsDir)) {
+        projectConfiguration.projectType = 'application';
+    }
+    else if (typeof nxJson?.workspaceLayout?.libsDir !== 'undefined' &&
+        projectRoot.startsWith(nxJson.workspaceLayout.libsDir)) {
+        projectConfiguration.projectType = 'library';
+    }
+    return projectConfiguration;
 }
 exports.buildProjectConfigurationFromPackageJson = buildProjectConfigurationFromPackageJson;
 /**

package/src/plugins/project-json/build-nodes/package-json-next-to-project-json.js

@@ -5,6 +5,7 @@ const path_1 = require("path");
 const fs_1 = require("fs");
 const fileutils_1 = require("../../../utils/fileutils");
 const package_json_1 = require("../../../utils/package-json");
+const package_json_workspaces_1 = require("../../package-json-workspaces");
 // TODO: Remove this one day, this should not need to be done.
 exports.PackageJsonProjectsNextToProjectJsonPlugin = {
     // Its not a problem if plugins happen to have same name, and this
@@ -27,8 +28,14 @@ exports.PackageJsonProjectsNextToProjectJsonPlugin = {
 exports.default = exports.PackageJsonProjectsNextToProjectJsonPlugin;
 function createProjectFromPackageJsonNextToProjectJson(projectJsonPath, workspaceRoot) {
     const root = (0, path_1.dirname)(projectJsonPath);
-    const packageJsonPath = (0, path_1.join)(workspaceRoot, root, 'package.json');
-    if (!(0, fs_1.existsSync)(packageJsonPath)) {
+    const relativePackageJsonPath = (0, path_1.join)(root, 'package.json');
+    const packageJsonPath = (0, path_1.join)(workspaceRoot, relativePackageJsonPath);
+    const readJson = (f) => (0, fileutils_1.readJsonFile)((0, path_1.join)(workspaceRoot, f));
+    // Do not create projects for package.json files
+    // that are part of the package manager workspaces
+    // Those package.json files will be processed later on
+    const matcher = (0, package_json_workspaces_1.buildPackageJsonWorkspacesMatcher)(workspaceRoot, readJson);
+    if (!(0, fs_1.existsSync)(packageJsonPath) || matcher(relativePackageJsonPath)) {
         return null;
     }
     try {
@@ -40,6 +47,7 @@ function createProjectFromPackageJsonNextToProjectJson(projectJsonPath, workspac
             root,
             targets: (0, package_json_1.readTargetsFromPackageJson)(packageJson),
             metadata: (0, package_json_1.getMetadataFromPackageJson)(packageJson),
+            tags: (0, package_json_1.getTagsFromPackageJson)(packageJson),
         };
     }
     catch (e) {

package/src/plugins/target-defaults/target-defaults-plugin.d.ts

@@ -17,6 +17,7 @@ export declare function getTargetInfo(target: string, projectJsonTargets: Record
         [x: string]: any;
         description?: string;
         technologies?: string[];
+        nonAtomizedTarget?: string;
     };
     executor?: undefined;
     options?: undefined;
@@ -31,6 +32,7 @@ export declare function getTargetInfo(target: string, projectJsonTargets: Record
         [x: string]: any;
         description?: string;
         technologies?: string[];
+        nonAtomizedTarget?: string;
     };
     command?: undefined;
 } | {
@@ -44,6 +46,7 @@ export declare function getTargetInfo(target: string, projectJsonTargets: Record
         [x: string]: any;
         description?: string;
         technologies?: string[];
+        nonAtomizedTarget?: string;
     };
     command?: undefined;
 } | {
@@ -52,6 +55,7 @@ export declare function getTargetInfo(target: string, projectJsonTargets: Record
         [x: string]: any;
         description?: string;
         technologies?: string[];
+        nonAtomizedTarget?: string;
     };
     command?: undefined;
     options?: undefined;
@@ -66,6 +70,7 @@ export declare function getTargetInfo(target: string, projectJsonTargets: Record
         [x: string]: any;
         description?: string;
         technologies?: string[];
+        nonAtomizedTarget?: string;
     };
     command?: undefined;
 } | {

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

@@ -76,7 +76,7 @@ async function loadNxPlugins(plugins, root = workspace_root_1.workspaceRoot) {
     plugins = await normalizePlugins(plugins, root);
     const cleanupFunctions = [];
     for (const plugin of plugins) {
-        const [loadedPluginPromise, cleanup] = loadingMethod(plugin, root);
+        const [loadedPluginPromise, cleanup] = await loadingMethod(plugin, root);
         result.push(loadedPluginPromise);
         cleanupFunctions.push(cleanup);
     }

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

@@ -1,3 +1,3 @@
 import { PluginConfiguration } from '../../../config/nx-json';
 import { LoadedNxPlugin } from '../internal-api';
-export declare function loadNxPluginInIsolation(plugin: PluginConfiguration, root?: string): [Promise<LoadedNxPlugin>, () => void];
+export declare function loadNxPluginInIsolation(plugin: PluginConfiguration, root?: string): Promise<readonly [Promise<LoadedNxPlugin>, () => void]>;

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

@@ -3,18 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.loadNxPluginInIsolation = void 0;
 const workspace_root_1 = require("../../../utils/workspace-root");
 const plugin_pool_1 = require("./plugin-pool");
-/**
- * Used to ensure 1 plugin : 1 worker
- */
-const remotePluginCache = new Map();
-function loadNxPluginInIsolation(plugin, root = workspace_root_1.workspaceRoot) {
-    const cacheKey = JSON.stringify(plugin);
-    if (remotePluginCache.has(cacheKey)) {
-        return [remotePluginCache.get(cacheKey), () => { }];
-    }
-    const loadingPlugin = (0, plugin_pool_1.loadRemoteNxPlugin)(plugin, root);
-    remotePluginCache.set(cacheKey, loadingPlugin);
-    // We clean up plugin workers when Nx process completes.
-    return [loadingPlugin, () => { }];
+async function loadNxPluginInIsolation(plugin, root = workspace_root_1.workspaceRoot) {
+    const [loadingPlugin, cleanup] = await (0, plugin_pool_1.loadRemoteNxPlugin)(plugin, root);
+    return [
+        loadingPlugin,
+        () => {
+            cleanup();
+        },
+    ];
 }
 exports.loadNxPluginInIsolation = loadNxPluginInIsolation;

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

@@ -1,9 +1,11 @@
 /// <reference types="node" />
+/// <reference types="node" />
 import { ProjectGraph, ProjectGraphProcessorContext } from '../../../config/project-graph';
 import { PluginConfiguration } from '../../../config/nx-json';
-import { CreateDependenciesContext, CreateMetadataContext, CreateNodesContext } from '../public-api';
+import { CreateDependenciesContext, CreateMetadataContext, CreateNodesContextV2 } from '../public-api';
 import { LoadedNxPlugin } from '../internal-api';
 import { Serializable } from 'child_process';
+import { Socket } from 'net';
 export interface PluginWorkerLoadMessage {
     type: 'load';
     payload: {
@@ -31,7 +33,7 @@ export interface PluginWorkerCreateNodesMessage {
     type: 'createNodes';
     payload: {
         configFiles: string[];
-        context: CreateNodesContext;
+        context: CreateNodesContextV2;
         tx: string;
     };
 }
@@ -112,9 +114,10 @@ export declare function isPluginWorkerMessage(message: Serializable): message is
 export declare function isPluginWorkerResult(message: Serializable): message is PluginWorkerResult;
 type MaybePromise<T> = T | Promise<T>;
 type MessageHandlerReturn<T extends PluginWorkerMessage | PluginWorkerResult> = T extends PluginWorkerResult ? MaybePromise<PluginWorkerMessage | void> : MaybePromise<PluginWorkerResult | void>;
-export declare function consumeMessage<T extends PluginWorkerMessage | PluginWorkerResult>(raw: T, handlers: {
+export declare function consumeMessage<T extends PluginWorkerMessage | PluginWorkerResult>(socket: Socket, raw: T, handlers: {
     [K in T['type']]: (payload: Extract<T, {
         type: K;
     }>['payload']) => MessageHandlerReturn<T>;
 }): Promise<void>;
+export declare function sendMessageOverSocket(socket: Socket, message: PluginWorkerMessage | PluginWorkerResult): void;
 export {};

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.consumeMessage = exports.isPluginWorkerResult = exports.isPluginWorkerMessage = void 0;
+exports.sendMessageOverSocket = exports.consumeMessage = exports.isPluginWorkerResult = exports.isPluginWorkerMessage = void 0;
 function isPluginWorkerMessage(message) {
     return (typeof message === 'object' &&
         'type' in message &&
@@ -10,6 +10,7 @@ function isPluginWorkerMessage(message) {
             'createNodes',
             'createDependencies',
             'processProjectGraph',
+            'createMetadata',
         ].includes(message.type));
 }
 exports.isPluginWorkerMessage = isPluginWorkerMessage;
@@ -22,19 +23,24 @@ function isPluginWorkerResult(message) {
             'createNodesResult',
             'createDependenciesResult',
             'processProjectGraphResult',
+            'createMetadataResult',
         ].includes(message.type));
 }
 exports.isPluginWorkerResult = isPluginWorkerResult;
 // Takes a message and a map of handlers and calls the appropriate handler
 // type safe and requires all handlers to be handled
-async function consumeMessage(raw, handlers) {
+async function consumeMessage(socket, raw, handlers) {
     const message = raw;
     const handler = handlers[message.type];
     if (handler) {
         const response = await handler(message.payload);
         if (response) {
-            process.send(response);
+            sendMessageOverSocket(socket, response);
         }
     }
 }
 exports.consumeMessage = consumeMessage;
+function sendMessageOverSocket(socket, message) {
+    socket.write(JSON.stringify(message) + String.fromCodePoint(4));
+}
+exports.sendMessageOverSocket = sendMessageOverSocket;

package/src/project-graph/plugins/isolation/plugin-pool.d.ts

@@ -1,3 +1,3 @@
 import { PluginConfiguration } from '../../../config/nx-json';
 import { LoadedNxPlugin } from '../internal-api';
-export declare function loadRemoteNxPlugin(plugin: PluginConfiguration, root: string): Promise<LoadedNxPlugin>;
+export declare function loadRemoteNxPlugin(plugin: PluginConfiguration, root: string): Promise<[Promise<LoadedNxPlugin>, () => void]>;

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

@@ -6,46 +6,46 @@ const path = require("path");
 // TODO (@AgentEnder): After scoped verbose logging is implemented, re-add verbose logs here.
 // import { logger } from '../../utils/logger';
 const internal_api_1 = require("../internal-api");
+const socket_utils_1 = require("../../../daemon/socket-utils");
+const consume_messages_from_socket_1 = require("../../../utils/consume-messages-from-socket");
 const messaging_1 = require("./messaging");
+const net_1 = require("net");
 const cleanupFunctions = new Set();
 const pluginNames = new Map();
-function loadRemoteNxPlugin(plugin, root) {
-    // this should only really be true when running unit tests within
-    // the Nx repo. We still need to start the worker in this case,
-    // but its typescript.
-    const isWorkerTypescript = path.extname(__filename) === '.ts';
-    const workerPath = path.join(__dirname, 'plugin-worker');
-    const env = {
-        ...process.env,
-        ...(isWorkerTypescript
-            ? {
-                // Ensures that the worker uses the same tsconfig as the main process
-                TS_NODE_PROJECT: path.join(__dirname, '../../../../tsconfig.lib.json'),
-            }
-            : {}),
-    };
-    const worker = (0, child_process_1.fork)(workerPath, [], {
-        stdio: ['ignore', 'inherit', 'inherit', 'ipc'],
-        env,
-        execArgv: [
-            ...process.execArgv,
-            // If the worker is typescript, we need to register ts-node
-            ...(isWorkerTypescript ? ['-r', 'ts-node/register'] : []),
-        ],
-    });
-    worker.send({ type: 'load', payload: { plugin, root } });
-    // logger.verbose(`[plugin-worker] started worker: ${worker.pid}`);
+const MAX_MESSAGE_WAIT = 1000 * 60 * 5; // 5 minutes
+const nxPluginWorkerCache = (global['nxPluginWorkerCache'] ??= new Map());
+async function loadRemoteNxPlugin(plugin, root) {
+    const cacheKey = JSON.stringify({ plugin, root });
+    if (nxPluginWorkerCache.has(cacheKey)) {
+        return [nxPluginWorkerCache.get(cacheKey), () => { }];
+    }
+    const { worker, socket } = await startPluginWorker();
     const pendingPromises = new Map();
     const exitHandler = createWorkerExitHandler(worker, pendingPromises);
     const cleanupFunction = () => {
         worker.off('exit', exitHandler);
+        socket.destroy();
         shutdownPluginWorker(worker);
+        nxPluginWorkerCache.delete(cacheKey);
     };
     cleanupFunctions.add(cleanupFunction);
-    return new Promise((res, rej) => {
-        worker.on('message', createWorkerHandler(worker, pendingPromises, res, rej));
+    const pluginPromise = new Promise((res, rej) => {
+        (0, messaging_1.sendMessageOverSocket)(socket, {
+            type: 'load',
+            payload: { plugin, root },
+        });
+        // logger.verbose(`[plugin-worker] started worker: ${worker.pid}`);
+        const loadTimeout = setTimeout(() => {
+            rej(new Error('Plugin worker timed out when loading plugin:' + plugin));
+        }, MAX_MESSAGE_WAIT);
+        socket.on('data', (0, consume_messages_from_socket_1.consumeMessagesFromSocket)(createWorkerHandler(worker, pendingPromises, (val) => {
+            clearTimeout(loadTimeout);
+            res(val);
+        }, rej, socket)));
         worker.on('exit', exitHandler);
     });
+    nxPluginWorkerCache.set(cacheKey, pluginPromise);
+    return [pluginPromise, cleanupFunction];
 }
 exports.loadRemoteNxPlugin = loadRemoteNxPlugin;
 function shutdownPluginWorker(worker) {
@@ -62,13 +62,15 @@ function shutdownPluginWorker(worker) {
  * @param onloadError Rejecter for RemotePlugin promise
  * @returns Function to handle messages from the worker
  */
-function createWorkerHandler(worker, pending, onload, onloadError) {
+function createWorkerHandler(worker, pending, onload, onloadError, socket) {
     let pluginName;
-    return function (message) {
+    let txId = 0;
+    return function (raw) {
+        const message = JSON.parse(raw);
         if (!(0, messaging_1.isPluginWorkerResult)(message)) {
             return;
         }
-        return (0, messaging_1.consumeMessage)(message, {
+        return (0, messaging_1.consumeMessage)(socket, message, {
             'load-result': (result) => {
                 if (result.success) {
                     const { name, createNodesPattern, include, exclude } = result;
@@ -82,9 +84,9 @@ function createWorkerHandler(worker, pending, onload, onloadError) {
                             ? [
                                 createNodesPattern,
                                 (configFiles, ctx) => {
-                                    const tx = pluginName + ':createNodes:' + performance.now();
+                                    const tx = pluginName + worker.pid + ':createNodes:' + txId++;
                                     return registerPendingPromise(tx, pending, () => {
-                                        worker.send({
+                                        (0, messaging_1.sendMessageOverSocket)(socket, {
                                             type: 'createNodes',
                                             payload: { configFiles, context: ctx, tx },
                                         });
@@ -94,9 +96,9 @@ function createWorkerHandler(worker, pending, onload, onloadError) {
                             : undefined,
                         createDependencies: result.hasCreateDependencies
                             ? (ctx) => {
-                                const tx = pluginName + ':createDependencies:' + performance.now();
+                                const tx = pluginName + worker.pid + ':createDependencies:' + txId++;
                                 return registerPendingPromise(tx, pending, () => {
-                                    worker.send({
+                                    (0, messaging_1.sendMessageOverSocket)(socket, {
                                         type: 'createDependencies',
                                         payload: { context: ctx, tx },
                                     });
@@ -105,9 +107,9 @@ function createWorkerHandler(worker, pending, onload, onloadError) {
                             : undefined,
                         processProjectGraph: result.hasProcessProjectGraph
                             ? (graph, ctx) => {
-                                const tx = pluginName + ':processProjectGraph:' + performance.now();
+                                const tx = pluginName + worker.pid + ':processProjectGraph:' + txId++;
                                 return registerPendingPromise(tx, pending, () => {
-                                    worker.send({
+                                    (0, messaging_1.sendMessageOverSocket)(socket, {
                                         type: 'processProjectGraph',
                                         payload: { graph, ctx, tx },
                                     });
@@ -116,9 +118,9 @@ function createWorkerHandler(worker, pending, onload, onloadError) {
                             : undefined,
                         createMetadata: result.hasCreateMetadata
                             ? (graph, ctx) => {
-                                const tx = pluginName + ':createMetadata:' + performance.now();
+                                const tx = pluginName + worker.pid + ':createMetadata:' + txId++;
                                 return registerPendingPromise(tx, pending, () => {
-                                    worker.send({
+                                    (0, messaging_1.sendMessageOverSocket)(socket, {
                                         type: 'createMetadata',
                                         payload: { graph, context: ctx, tx },
                                     });
@@ -177,19 +179,30 @@ function createWorkerExitHandler(worker, pendingPromises) {
         }
     };
 }
-process.on('exit', () => {
+let cleanedUp = false;
+const exitHandler = () => {
+    if (cleanedUp)
+        return;
     for (const fn of cleanupFunctions) {
         fn();
     }
-});
+    cleanedUp = true;
+};
+process.on('exit', exitHandler);
+process.on('SIGINT', exitHandler);
+process.on('SIGTERM', exitHandler);
 function registerPendingPromise(tx, pending, callback) {
-    let resolver, rejector;
+    let resolver, rejector, timeout;
     const promise = new Promise((res, rej) => {
-        resolver = res;
         rejector = rej;
+        resolver = res;
+        timeout = setTimeout(() => {
+            rej(new Error(`Plugin worker timed out when processing message ${tx}`));
+        }, MAX_MESSAGE_WAIT);
         callback();
     }).finally(() => {
         pending.delete(tx);
+        clearTimeout(timeout);
     });
     pending.set(tx, {
         promise,
@@ -198,3 +211,70 @@ function registerPendingPromise(tx, pending, callback) {
     });
     return promise;
 }
+global.nxPluginWorkerCount ??= 0;
+async function startPluginWorker() {
+    // this should only really be true when running unit tests within
+    // the Nx repo. We still need to start the worker in this case,
+    // but its typescript.
+    const isWorkerTypescript = path.extname(__filename) === '.ts';
+    const workerPath = path.join(__dirname, 'plugin-worker');
+    const env = {
+        ...process.env,
+        ...(isWorkerTypescript
+            ? {
+                // Ensures that the worker uses the same tsconfig as the main process
+                TS_NODE_PROJECT: path.join(__dirname, '../../../../tsconfig.lib.json'),
+            }
+            : {}),
+    };
+    const ipcPath = (0, socket_utils_1.getPluginOsSocketPath)([process.pid, global.nxPluginWorkerCount++].join('-'));
+    const worker = (0, child_process_1.fork)(workerPath, [ipcPath], {
+        stdio: process.stdout.isTTY ? 'inherit' : 'ignore',
+        env,
+        execArgv: [
+            ...process.execArgv,
+            // If the worker is typescript, we need to register ts-node
+            ...(isWorkerTypescript ? ['-r', 'ts-node/register'] : []),
+        ],
+        detached: true,
+    });
+    worker.disconnect();
+    worker.unref();
+    let attempts = 0;
+    return new Promise((resolve, reject) => {
+        const id = setInterval(async () => {
+            const socket = await isServerAvailable(ipcPath);
+            if (socket) {
+                socket.unref();
+                clearInterval(id);
+                resolve({
+                    worker,
+                    socket,
+                });
+            }
+            else if (attempts > 1000) {
+                // daemon fails to start, the process probably exited
+                // we print the logs and exit the client
+                reject('Failed to start plugin worker.');
+            }
+            else {
+                attempts++;
+            }
+        }, 10);
+    });
+}
+function isServerAvailable(ipcPath) {
+    return new Promise((resolve) => {
+        try {
+            const socket = (0, net_1.connect)(ipcPath, () => {
+                resolve(socket);
+            });
+            socket.once('error', () => {
+                resolve(false);
+            });
+        }
+        catch (err) {
+            resolve(false);
+        }
+    });
+}