nx 22.7.0 → 22.7.2

package/dist/src/tasks-runner/life-cycles/task-history-life-cycle.js

@@ -79,14 +79,25 @@ class TaskHistoryLifeCycle {
     }
     printFlakyTasksMessage() {
         if (this.flakyTasks?.length > 0) {
+            const MAX_VISIBLE_FLAKY = 5;
+            const visibleFlaky = this.flakyTasks.length > MAX_VISIBLE_FLAKY + 1
+                ? this.flakyTasks.slice(0, MAX_VISIBLE_FLAKY)
+                : this.flakyTasks;
+            const hiddenCount = this.flakyTasks.length - visibleFlaky.length;
+            const flakyRows = visibleFlaky.map((hash) => {
+                const taskRun = this.taskRuns.get(hash);
+                return `  ${(0, serialize_target_1.serializeTarget)(taskRun.target.project, taskRun.target.target, taskRun.target.configuration)}`;
+            });
+            if (hiddenCount > 0) {
+                flakyRows.push(`  ${hiddenCount} more...`);
+            }
             output_1.output.warn({
-                title: `Nx detected ${this.flakyTasks.length === 1 ? 'a flaky task' : ' flaky tasks'}`,
+                title: `Nx detected ${this.flakyTasks.length === 1
+                    ? 'a flaky task'
+                    : `${this.flakyTasks.length} flaky tasks`}`,
                 bodyLines: [
                     ,
-                    ...this.flakyTasks.map((hash) => {
-                        const taskRun = this.taskRuns.get(hash);
-                        return `  ${(0, serialize_target_1.serializeTarget)(taskRun.target.project, taskRun.target.target, taskRun.target.configuration)}`;
-                    }),
+                    ...flakyRows,
                     ...((0, nx_cloud_utils_1.isNxCloudUsed)((0, nx_json_1.readNxJson)())
                         ? []
                         : [

package/dist/src/tasks-runner/life-cycles/tui-summary-life-cycle.js

@@ -67,6 +67,12 @@ function getTuiTerminalSummaryLifeCycle({ projectNames, tasks, taskGraph, args,
             displayStoppedTasks.add(taskId);
             inProgressTasks.delete(taskId);
         }
+        else if (taskStatus === 2 /* NativeTaskStatus.Skipped */) {
+            // Skipped tasks don't get an endTasks() call; clear them here so the run
+            // summary doesn't treat them as still-in-progress and report Cancelled.
+            tasksToTaskStatus[taskId] = 'skipped';
+            inProgressTasks.delete(taskId);
+        }
     };
     lifeCycle.endTasks = (taskResults) => {
         for (const { task, status, terminalOutput } of taskResults) {
@@ -132,10 +138,13 @@ function getTuiTerminalSummaryLifeCycle({ projectNames, tasks, taskGraph, args,
         (0, task_history_life_cycle_1.getTasksHistoryLifeCycle)().printFlakyTasksMessage();
     };
     const printRunOneSummary = ({ failure, cancelled, }) => {
-        // Prints task outputs in the order they were completed
-        // above the summary, since run-one should print all task results.
+        // Print task outputs in completion order above the summary.
         for (const taskId of taskIdsInTheOrderTheyStart) {
             const taskStatus = tasksToTaskStatus[taskId];
+            // Skipped tasks never ran; don't print a misleading `> nx run` header.
+            if (taskStatus === 'skipped') {
+                continue;
+            }
             const terminalOutput = getTerminalOutput(taskId);
             output_1.output.logCommandOutput(taskId, taskStatus, terminalOutput);
         }

package/dist/src/tasks-runner/run-command.js

@@ -11,9 +11,9 @@ const tslib_1 = require("tslib");
 const enquirer_1 = require("enquirer");
 const node_path_1 = require("node:path");
 const node_util_1 = require("node:util");
-const ora = require('ora');
 const nx_json_1 = require("../config/nx-json");
 const client_1 = require("../daemon/client/client");
+const spinner_1 = require("../utils/spinner");
 const create_task_hasher_1 = require("../hasher/create-task-hasher");
 const hash_task_1 = require("../hasher/hash-task");
 const native_1 = require("../native");
@@ -22,6 +22,7 @@ const project_graph_1 = require("../project-graph/project-graph");
 const handle_errors_1 = require("../utils/handle-errors");
 const is_ci_1 = require("../utils/is-ci");
 const nx_cloud_utils_1 = require("../utils/nx-cloud-utils");
+const logger_1 = require("../utils/logger");
 const nx_key_1 = require("../utils/nx-key");
 const output_1 = require("../utils/output");
 const sync_generators_1 = require("../utils/sync-generators");
@@ -324,6 +325,10 @@ async function runCommand(projectsToRun, currentProjectGraph, { nxJson }, nxArgs
     return status;
 }
 async function runCommandForTasks(projectsToRun, currentProjectGraph, { nxJson }, nxArgs, overrides, initiatingProject, extraTargetDependencies, extraOptions) {
+    // Kick off the license lookup in the background so it overlaps with task
+    // execution. The log itself is deferred to the print site below so it
+    // never lands in the middle of task output.
+    const nxKeyPromise = (0, nx_key_1.getNxKeyInformation)().catch(() => null);
     const projectNames = projectsToRun.map((t) => t.name);
     const projectNameSet = new Set(projectNames);
     const { projectGraph, taskGraph } = await ensureWorkspaceIsInSyncAndGetGraphs(currentProjectGraph, nxJson, projectNames, nxArgs, overrides, extraTargetDependencies, extraOptions);
@@ -348,7 +353,9 @@ async function runCommandForTasks(projectsToRun, currentProjectGraph, { nxJson }
             printSummary();
         }
         await printConfigureAiAgentsDisclaimer();
-        await (0, nx_key_1.printNxKey)();
+        const nxKey = await nxKeyPromise;
+        if (nxKey)
+            logger_1.logger.log((0, nx_key_1.createNxKeyLicenseeInformation)(nxKey));
         return {
             taskResults,
             completed: didCommandComplete(tasks, taskResults),
@@ -486,8 +493,7 @@ async function ensureWorkspaceIsInSyncAndGetGraphs(projectGraph, nxJson, project
     const applyChanges = nxJson.sync?.applyChanges === true ||
         (await promptForApplyingSyncGeneratorChanges());
     if (applyChanges) {
-        const spinner = ora('Syncing the workspace...');
-        spinner.start();
+        const spinner = spinner_1.globalSpinner.start('Syncing the workspace...');
         // Flush sync generator changes to disk
         const flushResult = await (0, sync_generators_1.flushSyncGeneratorChanges)(results);
         if ('generatorFailures' in flushResult) {

package/dist/src/tasks-runner/task-orchestrator.js

@@ -29,6 +29,14 @@ const task_env_1 = require("./task-env");
 const tasks_schedule_1 = require("./tasks-schedule");
 const utils_1 = require("./utils");
 const shared_running_task_1 = require("./running-tasks/shared-running-task");
+/**
+ * Resolve a batch executor's per-task result to a TaskStatus. Prefers an
+ * explicit `status` from the executor; falls back to the `success` boolean
+ * for executors that pre-date the `status` field.
+ */
+function resolveBatchTaskStatus(result) {
+    return result.status ?? (result.success ? 'success' : 'failure');
+}
 class TaskOrchestrator {
     // endregion internal state
     constructor(hasher, initiatingProject, initiatingTasks, projectGraph, taskGraph, nxJson, options, bail, daemon, outputStyle, taskGraphForHashing = taskGraph) {
@@ -57,7 +65,12 @@ class TaskOrchestrator {
         // region internal state
         this.batchEnv = (0, task_env_1.getEnvVariablesForBatchProcess)(this.options.skipNxCache, this.options.captureStderr);
         this.reverseTaskDeps = (0, utils_1.calculateReverseDeps)(this.taskGraph);
-        this.initializingTaskIds = new Set(this.initiatingTasks.map((t) => t.id));
+        // `nx:noop` initiating tasks exit instantly via the fast-path in
+        // `spawnProcess`. If we treat the noop itself as the keep-alive anchor for
+        // its continuous dependencies, `cleanUpUnneededContinuousTasks` kills those
+        // children the moment the noop finishes. Expand through noops so the
+        // underlying real tasks become the anchors.
+        this.initializingTaskIds = (0, utils_1.expandInitiatingTasksThroughNoop)(this.initiatingTasks, this.taskGraph, this.projectGraph);
         this.processedTasks = new Map();
         this.completedTasks = new Map();
         this.waitingForTasks = [];
@@ -493,11 +506,18 @@ class TaskOrchestrator {
             // Heavy operations (caching, scheduling, complete) happen at batch-end in postRunSteps
             batchProcess.onTaskResults((taskId, result) => {
                 const task = this.taskGraph.tasks[taskId];
-                const status = result.success ? 'success' : 'failure';
-                this.options.lifeCycle.printTaskTerminalOutput(task, status, result.terminalOutput ?? '');
+                const status = resolveBatchTaskStatus(result);
+                // Append before print so printTaskTerminalOutput finds the PTY already
+                // populated and no-ops; reversing the order writes terminalOutput twice.
                 if (result.terminalOutput) {
                     this.options.lifeCycle.appendTaskOutput(taskId, result.terminalOutput, false);
                 }
+                // Skipped tasks didn't run, so they have no terminal output and don't
+                // need a per-task PTY — calling printTaskTerminalOutput would otherwise
+                // allocate one just to write a cursor-hide escape.
+                if (status !== 'skipped') {
+                    this.options.lifeCycle.printTaskTerminalOutput(task, status, result.terminalOutput ?? '');
+                }
                 task.startTime = result.startTime;
                 task.endTime = result.endTime;
                 if (result.startTime && result.endTime) {
@@ -511,10 +531,11 @@ class TaskOrchestrator {
                 const task = this.taskGraph.tasks[taskId];
                 task.startTime = result.startTime;
                 task.endTime = result.endTime;
+                const status = resolveBatchTaskStatus(result);
                 return {
-                    code: result.success ? 0 : 1,
+                    code: status === 'success' ? 0 : 1,
                     task,
-                    status: (result.success ? 'success' : 'failure'),
+                    status,
                     terminalOutput: result.terminalOutput,
                 };
             });

package/dist/src/tasks-runner/utils.d.ts

@@ -31,6 +31,17 @@ export declare function getOutputsForTargetAndConfiguration(target: Task['target
 export declare function interpolate(template: string, data: any): string;
 export declare function getTargetConfigurationForTask(task: Task, projectGraph: ProjectGraph): TargetConfiguration | undefined;
 export declare function getExecutorNameForTask(task: Task, projectGraph: ProjectGraph): string;
+/**
+ * Expand a set of initiating task IDs by walking through any `nx:noop` tasks
+ * and replacing them with their direct dependencies + continuous dependencies.
+ * Non-noop tasks are kept as-is; cycles are safe.
+ *
+ * An `nx:noop` executor returns immediately, so if it is the only thing
+ * anchoring a continuous child, the child gets killed by
+ * `cleanUpUnneededContinuousTasks` the moment the noop completes. Treating the
+ * noop's dependencies as the real anchors preserves the intended orchestration.
+ */
+export declare function expandInitiatingTasksThroughNoop(initiatingTasks: Task[], taskGraph: TaskGraph, projectGraph: ProjectGraph): Set<string>;
 export declare function getExecutorForTask(task: Task, projects: Record<string, ProjectConfiguration>): ExecutorConfig & {
     isNgCompat: boolean;
     isNxExecutor: boolean;

package/dist/src/tasks-runner/utils.js

@@ -14,6 +14,7 @@ exports.getOutputsForTargetAndConfiguration = getOutputsForTargetAndConfiguratio
 exports.interpolate = interpolate;
 exports.getTargetConfigurationForTask = getTargetConfigurationForTask;
 exports.getExecutorNameForTask = getExecutorNameForTask;
+exports.expandInitiatingTasksThroughNoop = expandInitiatingTasksThroughNoop;
 exports.getExecutorForTask = getExecutorForTask;
 exports.getCustomHasher = getCustomHasher;
 exports.removeTasksFromTaskGraph = removeTasksFromTaskGraph;
@@ -291,6 +292,42 @@ function getTargetConfigurationForTask(task, projectGraph) {
 function getExecutorNameForTask(task, projectGraph) {
     return getTargetConfigurationForTask(task, projectGraph)?.executor;
 }
+/**
+ * Expand a set of initiating task IDs by walking through any `nx:noop` tasks
+ * and replacing them with their direct dependencies + continuous dependencies.
+ * Non-noop tasks are kept as-is; cycles are safe.
+ *
+ * An `nx:noop` executor returns immediately, so if it is the only thing
+ * anchoring a continuous child, the child gets killed by
+ * `cleanUpUnneededContinuousTasks` the moment the noop completes. Treating the
+ * noop's dependencies as the real anchors preserves the intended orchestration.
+ */
+function expandInitiatingTasksThroughNoop(initiatingTasks, taskGraph, projectGraph) {
+    const expanded = new Set();
+    const visited = new Set();
+    const queue = initiatingTasks.map((t) => t.id);
+    while (queue.length > 0) {
+        const taskId = queue.shift();
+        if (visited.has(taskId))
+            continue;
+        visited.add(taskId);
+        const task = taskGraph.tasks[taskId];
+        if (!task)
+            continue;
+        if (getExecutorNameForTask(task, projectGraph) === 'nx:noop') {
+            for (const dep of taskGraph.dependencies[taskId] ?? []) {
+                queue.push(dep);
+            }
+            for (const dep of taskGraph.continuousDependencies[taskId] ?? []) {
+                queue.push(dep);
+            }
+        }
+        else {
+            expanded.add(taskId);
+        }
+    }
+    return expanded;
+}
 function getExecutorForTask(task, projects) {
     const executor = projects[task.target.project]?.targets?.[task.target.target]?.executor;
     const [nodeModule, executorName] = (0, executor_utils_1.parseExecutor)(executor);

package/dist/src/utils/ab-testing.js

@@ -21,6 +21,18 @@ const messageOptions = {
             ],
             footer: '\nFree for small teams. Remote caching and task distribution. 2-minute setup: https://nx.dev/nx-cloud',
         },
+        {
+            code: 'cloud-self-healing-remote-cache',
+            message: `Would you like to enable AI-powered Self-Healing CI and Remote Caching?`,
+            initial: 0,
+            choices: [
+                { value: 'yes', name: 'Yes' },
+                { value: 'skip', name: 'Skip for now' },
+                { value: 'never', name: pc.dim("No, don't ask again") },
+            ],
+            footer: '\nLearn about it at https://nx.dev/nx-cloud',
+            hint: `\n(it's free and can be disabled any time)`,
+        },
     ],
     setupViewLogs: [
         {

package/dist/src/utils/compile-cache.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Enables V8's on-disk bytecode cache for the current process.
+ *
+ * Calls `module.enableCompileCache()` with no arguments and lets Node pick
+ * the location, which means Node's standard env vars work transparently:
+ *  - `NODE_COMPILE_CACHE=<dir>`     — override the cache directory.
+ *  - `NODE_DISABLE_COMPILE_CACHE=1` — disable entirely.
+ *
+ * The default location lives under the OS temp dir keyed by V8 version, so
+ * the cache is shared across workspaces and self-invalidates on Node
+ * upgrades — no nx-specific cleanup needed.
+ *
+ * Called at the entry point of every long-lived nx process (main CLI,
+ * daemon, plugin workers) via `enable-compile-cache.ts`, which side-effects
+ * this on import.
+ *
+ * Set `NX_COMPILE_CACHE=false` to opt out without disabling the cache for
+ * non-nx Node processes the way `NODE_DISABLE_COMPILE_CACHE` would.
+ *
+ * No-op on Node versions without the `module.enableCompileCache` API.
+ * Errors are swallowed — the compile cache is a pure performance
+ * optimization and must never break the CLI.
+ */
+export declare function enableCompileCache(...override: [unknown?]): boolean;

package/dist/src/utils/compile-cache.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enableCompileCache = enableCompileCache;
+const tslib_1 = require("tslib");
+const nodeModule = tslib_1.__importStar(require("node:module"));
+/**
+ * Enables V8's on-disk bytecode cache for the current process.
+ *
+ * Calls `module.enableCompileCache()` with no arguments and lets Node pick
+ * the location, which means Node's standard env vars work transparently:
+ *  - `NODE_COMPILE_CACHE=<dir>`     — override the cache directory.
+ *  - `NODE_DISABLE_COMPILE_CACHE=1` — disable entirely.
+ *
+ * The default location lives under the OS temp dir keyed by V8 version, so
+ * the cache is shared across workspaces and self-invalidates on Node
+ * upgrades — no nx-specific cleanup needed.
+ *
+ * Called at the entry point of every long-lived nx process (main CLI,
+ * daemon, plugin workers) via `enable-compile-cache.ts`, which side-effects
+ * this on import.
+ *
+ * Set `NX_COMPILE_CACHE=false` to opt out without disabling the cache for
+ * non-nx Node processes the way `NODE_DISABLE_COMPILE_CACHE` would.
+ *
+ * No-op on Node versions without the `module.enableCompileCache` API.
+ * Errors are swallowed — the compile cache is a pure performance
+ * optimization and must never break the CLI.
+ */
+function enableCompileCache(
+// Test seam: production callers omit this. `unknown` (rather than
+// `EnableCompileCacheFn | undefined`) lets tests pass a non-function to
+// simulate pre-22.8 Node where `module.enableCompileCache` is missing. We
+// read `arguments.length` so callers can *explicitly* pass `undefined`.
+...override) {
+    if (process.env.NX_COMPILE_CACHE === 'false')
+        return false;
+    const impl = override.length === 0
+        ? nodeModule.enableCompileCache
+        : override[0];
+    if (typeof impl !== 'function')
+        return false;
+    try {
+        impl();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/src/utils/enable-compile-cache.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/utils/enable-compile-cache.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// Side-effect-only module: import this as the *first* import in any nx
+// process entry point so V8's compile cache is enabled before the rest of
+// the import chain (which is what we actually want to cache) starts loading.
+const compile_cache_1 = require("./compile-cache");
+(0, compile_cache_1.enableCompileCache)();

package/dist/src/utils/has-nx-js-plugin.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Checks if `@nx/js` is installed by attempting to resolve its `package.json`.
+ *
+ * Lives in its own module so unit tests can `jest.doMock` it without having to
+ * intercept Node's resolver at the global level. The previous in-`package-json`
+ * definition was unreachable to mocks because callers in the same module
+ * referenced it via the local lexical binding rather than `module.exports`.
+ */
+export declare function hasNxJsPlugin(projectRoot: string, workspaceRoot: string): boolean;

package/dist/src/utils/has-nx-js-plugin.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasNxJsPlugin = hasNxJsPlugin;
+const installation_directory_1 = require("./installation-directory");
+/**
+ * Checks if `@nx/js` is installed by attempting to resolve its `package.json`.
+ *
+ * Lives in its own module so unit tests can `jest.doMock` it without having to
+ * intercept Node's resolver at the global level. The previous in-`package-json`
+ * definition was unreachable to mocks because callers in the same module
+ * referenced it via the local lexical binding rather than `module.exports`.
+ */
+function hasNxJsPlugin(projectRoot, workspaceRoot) {
+    try {
+        // nx-ignore-next-line
+        require.resolve('@nx/js/package.json', {
+            paths: [projectRoot, ...(0, installation_directory_1.getNxRequirePaths)(workspaceRoot), __dirname],
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/src/utils/installed-nx-version.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Resolve the workspace's installed `nx` version, or `null` if no installed
+ * `nx` can be located. Routed through a cache-shielded, self-reference-free
+ * `require.resolve` so the answer always reflects the workspace's
+ * `node_modules`/PnP store rather than whichever `nx` package happens to be
+ * loaded in the current process. See nrwl/nx#35444.
+ */
+export declare function getInstalledNxVersion(): string | null;

package/dist/src/utils/installed-nx-version.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getInstalledNxVersion = getInstalledNxVersion;
+const tslib_1 = require("tslib");
+const node_module_1 = tslib_1.__importStar(require("node:module"));
+const fileutils_1 = require("./fileutils");
+const workspace_root_1 = require("./workspace-root");
+const installation_directory_1 = require("./installation-directory");
+/**
+ * Resolve the workspace's installed `nx` version, or `null` if no installed
+ * `nx` can be located. Routed through a cache-shielded, self-reference-free
+ * `require.resolve` so the answer always reflects the workspace's
+ * `node_modules`/PnP store rather than whichever `nx` package happens to be
+ * loaded in the current process. See nrwl/nx#35444.
+ */
+function getInstalledNxVersion() {
+    const nxPackageJsonPath = resolvePackageJsonWithoutCachePollution('nx', (0, installation_directory_1.getNxRequirePaths)(workspace_root_1.workspaceRoot));
+    if (!nxPackageJsonPath) {
+        return null;
+    }
+    try {
+        return (0, fileutils_1.readJsonFile)(nxPackageJsonPath).version ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Resolve `<packageName>/package.json` via Node's CJS resolver while
+ * neutralising both ways `require.resolve(req, { paths })` can lie about
+ * the `paths` argument:
+ *
+ *   1. Process-wide `Module._pathCache` — swapped out for the duration of
+ *      the call, so any cache entries written are discarded and any
+ *      previously-poisoned entries are not read. Without this, an
+ *      in-process load of a second `nx` package (e.g. the temp `nx@latest`
+ *      install used by the daemon's AI-agents and console-status checks)
+ *      can poison the cache key this call uses and make us read the temp
+ *      path instead of the workspace path.
+ *
+ *   2. Package self-reference — when a file inside package `nx` calls
+ *      `require.resolve('nx/...')`, Node returns that calling package's
+ *      own file regardless of `paths`. We avoid that by issuing the
+ *      resolve from a `createRequire` rooted at a synthetic path that is
+ *      outside any package, so the resolver has no "self" to reference
+ *      and must honour `paths`.
+ *
+ * Node's single-threaded synchronous execution means `require.resolve` does
+ * not yield, so no other code in the process can observe the swapped cache.
+ */
+function resolvePackageJsonWithoutCachePollution(packageName, requirePaths) {
+    // `_pathCache` is an internal Node API not exposed in @types/node.
+    const realCache = node_module_1.default._pathCache;
+    node_module_1.default._pathCache = Object.create(null);
+    try {
+        const detachedRequire = (0, node_module_1.createRequire)('/__nx_detached_resolver__/x.js');
+        return detachedRequire.resolve(`${packageName}/package.json`, {
+            paths: requirePaths,
+        });
+    }
+    catch {
+        return null;
+    }
+    finally {
+        node_module_1.default._pathCache = realCache;
+    }
+}

package/dist/src/utils/logger.d.ts

@@ -1,7 +1,17 @@
 export declare const NX_PREFIX: string;
 export declare const NX_ERROR: string;
+type LogDriver = Pick<Console, 'warn' | 'error' | 'info' | 'log' | 'debug'>;
+export declare function createLogger(driver: LogDriver): {
+    warn: (...v: any[]) => void;
+    error: (s: any) => void;
+    info: (s: any) => void;
+    log: (...s: any[]) => void;
+    debug: (...s: any[]) => void;
+    fatal: (...s: any[]) => void;
+    verbose: (...s: any[]) => void;
+};
 export declare const logger: {
-    warn: (s: any) => void;
+    warn: (...v: any[]) => void;
     error: (s: any) => void;
     info: (s: any) => void;
     log: (...s: any[]) => void;
@@ -10,3 +20,4 @@ export declare const logger: {
     verbose: (...s: any[]) => void;
 };
 export declare function stripIndent(str: string): string;
+export {};

package/dist/src/utils/logger.js

@@ -1,47 +1,68 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.logger = exports.NX_ERROR = exports.NX_PREFIX = void 0;
+exports.createLogger = createLogger;
 exports.stripIndent = stripIndent;
 const tslib_1 = require("tslib");
 const pc = tslib_1.__importStar(require("picocolors"));
+const is_on_daemon_1 = require("../daemon/is-on-daemon");
+const logger_1 = require("../daemon/logger");
 exports.NX_PREFIX = pc.inverse(pc.bold(pc.cyan(' NX ')));
 exports.NX_ERROR = pc.inverse(pc.bold(pc.red(' ERROR ')));
-exports.logger = {
-    warn: (s) => console.warn(pc.bold(pc.yellow(s))),
-    error: (s) => {
-        if (typeof s === 'string' && s.startsWith('NX ')) {
-            console.error(`\n${exports.NX_ERROR} ${pc.bold(pc.red(s.slice(3)))}\n`);
-        }
-        else if (s instanceof Error && s.stack) {
-            console.error(pc.bold(pc.red(s.stack)));
-        }
-        else {
-            console.error(pc.bold(pc.red(s)));
-        }
-    },
-    info: (s) => {
-        if (typeof s === 'string' && s.startsWith('NX ')) {
-            console.info(`\n${exports.NX_PREFIX} ${pc.bold(s.slice(3))}\n`);
-        }
-        else {
-            console.info(s);
-        }
-    },
-    log: (...s) => {
-        console.log(...s);
-    },
-    debug: (...s) => {
-        console.debug(...s);
-    },
-    fatal: (...s) => {
-        console.error(...s);
-    },
-    verbose: (...s) => {
-        if (process.env.NX_VERBOSE_LOGGING === 'true') {
-            console.log(...s);
-        }
-    },
-};
+function createLogger(driver) {
+    return {
+        warn: (...v) => driver.warn(...v.map((s) => pc.bold(pc.yellow(s)))),
+        error: (s) => {
+            if (typeof s === 'string' && s.startsWith('NX ')) {
+                driver.error(`\n${exports.NX_ERROR} ${pc.bold(pc.red(s.slice(3)))}\n`);
+            }
+            else if (s instanceof Error && s.stack) {
+                driver.error(pc.bold(pc.red(s.stack)));
+            }
+            else {
+                driver.error(pc.bold(pc.red(s)));
+            }
+        },
+        info: (s) => {
+            if (typeof s === 'string' && s.startsWith('NX ')) {
+                driver.info(`\n${exports.NX_PREFIX} ${pc.bold(s.slice(3))}\n`);
+            }
+            else {
+                driver.info(s);
+            }
+        },
+        log: (...s) => {
+            driver.log(...s);
+        },
+        debug: (...s) => {
+            driver.debug(...s);
+        },
+        fatal: (...s) => {
+            driver.error(...s);
+        },
+        verbose: (...s) => {
+            if (process.env.NX_VERBOSE_LOGGING === 'true') {
+                // verbose logs go to stderr to prevent things like `nx show projects | grep`
+                // breaking when you enable verbose logging. The only potential breakage from
+                // this would be if a tool counts any output on stderr as being an issue, but
+                // there are likely other places that would trigger those same issues.
+                driver.warn(...s);
+            }
+        },
+    };
+}
+exports.logger = createLogger((0, is_on_daemon_1.isOnDaemon)()
+    ? (() => {
+        const log = logger_1.serverLogger.log.bind(logger_1.serverLogger);
+        return {
+            warn: log,
+            error: log,
+            debug: log,
+            info: log,
+            log: log,
+        };
+    })()
+    : console);
 function stripIndent(str) {
     const match = str.match(/^[ \t]*(?=\S)/gm);
     if (!match) {

package/dist/src/utils/nx-key.d.ts

@@ -1,6 +1,5 @@
 import type { NxKey } from '@nx/key';
 export declare function createNxKeyLicenseeInformation(nxKey: NxKey): string;
-export declare function printNxKey(): Promise<void>;
 export declare function getNxKeyInformation(): Promise<NxKey | null>;
 export declare class NxKeyNotInstalledError extends Error {
     constructor(e: Error);