nx 18.1.0-canary.20240312-9520aa2 → 18.1.0-canary.20240313-81df848

package/src/core/graph/runtime.js

@@ -1 +1 @@
-(()=>{"use strict";var e,r={},t={};function o(e){var n=t[e];if(void 0!==n)return n.exports;var i=t[e]={id:e,loaded:!1,exports:{}};return r[e].call(i.exports,i,i.exports,o),i.loaded=!0,i.exports}o.m=r,e=[],o.O=(r,t,n,i)=>{if(!t){var l=1/0;for(f=0;f<e.length;f++){for(var[t,n,i]=e[f],a=!0,u=0;u<t.length;u++)(!1&i||l>=i)&&Object.keys(o.O).every((e=>o.O[e](t[u])))?t.splice(u--,1):(a=!1,i<l&&(l=i));if(a){e.splice(f--,1);var d=n();void 0!==d&&(r=d)}}return r}i=i||0;for(var f=e.length;f>0&&e[f-1][2]>i;f--)e[f]=e[f-1];e[f]=[t,n,i]},o.n=e=>{var r=e&&e.__esModule?()=>e.default:()=>e;return o.d(r,{a:r}),r},o.d=(e,r)=>{for(var t in r)o.o(r,t)&&!o.o(e,t)&&Object.defineProperty(e,t,{enumerable:!0,get:r[t]})},o.g=function(){if("object"==typeof globalThis)return globalThis;try{return this||new Function("return this")()}catch(e){if("object"==typeof window)return window}}(),o.o=(e,r)=>Object.prototype.hasOwnProperty.call(e,r),o.r=e=>{"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})},o.nmd=e=>(e.paths=[],e.children||(e.children=[]),e),(()=>{var e={666:0};o.O.j=r=>0===e[r];var r=(r,t)=>{var n,i,[l,a,u]=t,d=0;if(l.some((r=>0!==e[r]))){for(n in a)o.o(a,n)&&(o.m[n]=a[n]);if(u)var f=u(o)}for(r&&r(t);d<l.length;d++)i=l[d],o.o(e,i)&&e[i]&&e[i][0](),e[i]=0;return o.O(f)},t=self.webpackChunk=self.webpackChunk||[];t.forEach(r.bind(null,0)),t.push=r.bind(null,t.push.bind(t))})()})();
+(()=>{"use strict";var e,r={},t={};function o(e){var n=t[e];if(void 0!==n)return n.exports;var i=t[e]={id:e,loaded:!1,exports:{}};return r[e].call(i.exports,i,i.exports,o),i.loaded=!0,i.exports}o.m=r,e=[],o.O=(r,t,n,i)=>{if(!t){var l=1/0;for(f=0;f<e.length;f++){for(var[t,n,i]=e[f],a=!0,u=0;u<t.length;u++)(!1&i||l>=i)&&Object.keys(o.O).every((e=>o.O[e](t[u])))?t.splice(u--,1):(a=!1,i<l&&(l=i));if(a){e.splice(f--,1);var d=n();void 0!==d&&(r=d)}}return r}i=i||0;for(var f=e.length;f>0&&e[f-1][2]>i;f--)e[f]=e[f-1];e[f]=[t,n,i]},o.n=e=>{var r=e&&e.__esModule?()=>e.default:()=>e;return o.d(r,{a:r}),r},o.d=(e,r)=>{for(var t in r)o.o(r,t)&&!o.o(e,t)&&Object.defineProperty(e,t,{enumerable:!0,get:r[t]})},o.g=function(){if("object"==typeof globalThis)return globalThis;try{return this||new Function("return this")()}catch(e){if("object"==typeof window)return window}}(),o.o=(e,r)=>Object.prototype.hasOwnProperty.call(e,r),o.r=e=>{"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})},o.nmd=e=>(e.paths=[],e.children||(e.children=[]),e),(()=>{var e={2:0};o.O.j=r=>0===e[r];var r=(r,t)=>{var n,i,[l,a,u]=t,d=0;if(l.some((r=>0!==e[r]))){for(n in a)o.o(a,n)&&(o.m[n]=a[n]);if(u)var f=u(o)}for(r&&r(t);d<l.length;d++)i=l[d],o.o(e,i)&&e[i]&&e[i][0](),e[i]=0;return o.O(f)},t=self.webpackChunk=self.webpackChunk||[];t.forEach(r.bind(null,0)),t.push=r.bind(null,t.push.bind(t))})()})();

package/src/core/graph/styles.js

@@ -1 +1 @@
-"use strict";(self.webpackChunk=self.webpackChunk||[]).push([[532],{22232:()=>{}},s=>{var e;e=22232,s(s.s=e)}]);
+"use strict";(self.webpackChunk=self.webpackChunk||[]).push([[3],{22232:(s,e,k)=>{k.r(e)}},s=>{var e;e=22232,s(s.s=e)}]);

package/src/executors/run-commands/run-commands.impl.d.ts

@@ -25,6 +25,8 @@ export interface RunCommandsOptions extends Json {
     args?: string | string[];
     envFile?: string;
     __unparsed__: string[];
+    usePty?: boolean;
+    streamOutput?: boolean;
 }
 export interface NormalizedRunCommandsOptions extends RunCommandsOptions {
     commands: {
@@ -41,5 +43,6 @@ export interface NormalizedRunCommandsOptions extends RunCommandsOptions {
 }
 export default function (options: RunCommandsOptions, context: ExecutorContext): Promise<{
     success: boolean;
+    terminalOutput: string;
 }>;
 export declare function interpolateArgsIntoCommand(command: string, opts: Pick<NormalizedRunCommandsOptions, 'args' | 'parsedArgs' | '__unparsed__' | 'unknownOptions'>, forwardAllArgs: boolean): string;

package/src/executors/run-commands/run-commands.impl.js

@@ -34,7 +34,8 @@ const propKeys = [
     'envFile',
     '__unparsed__',
     'env',
-    'mode',
+    'usePty',
+    'streamOutput',
     'verbose',
 ];
 async function default_1(options, context) {
@@ -48,10 +49,10 @@ async function default_1(options, context) {
         throw new Error('ERROR: Bad executor config for run-commands - "prefix", "color" and "bgColor" can only be set when "parallel=true".');
     }
     try {
-        const success = options.parallel
+        const result = options.parallel
             ? await runInParallel(normalized, context)
             : await runSerially(normalized, context);
-        return { success };
+        return result;
     }
     catch (e) {
         if (process.env.NX_VERBOSE_LOGGING === 'true') {
@@ -62,31 +63,48 @@ async function default_1(options, context) {
 }
 exports.default = default_1;
 async function runInParallel(options, context) {
-    const procs = options.commands.map((c) => createProcess(c, options.readyWhen, options.color, calculateCwd(options.cwd, context), options.env ?? {}, true).then((result) => ({
+    const procs = options.commands.map((c) => createProcess(c, options.readyWhen, options.color, calculateCwd(options.cwd, context), options.env ?? {}, true, options.usePty, options.streamOutput).then((result) => ({
         result,
         command: c.command,
     })));
+    let terminalOutput = '';
     if (options.readyWhen) {
         const r = await Promise.race(procs);
-        if (!r.result) {
-            process.stderr.write(`Warning: command "${r.command}" exited with non-zero status code`);
-            return false;
+        terminalOutput += r.result.terminalOutput;
+        if (!r.result.success) {
+            const output = `Warning: command "${r.command}" exited with non-zero status code`;
+            terminalOutput += output;
+            if (options.streamOutput) {
+                process.stderr.write(output);
+            }
+            return { success: false, terminalOutput };
         }
         else {
-            return true;
+            return { success: true, terminalOutput };
         }
     }
     else {
         const r = await Promise.all(procs);
-        const failed = r.filter((v) => !v.result);
+        terminalOutput += r.map((f) => f.result.terminalOutput).join('');
+        const failed = r.filter((v) => !v.result.success);
         if (failed.length > 0) {
-            failed.forEach((f) => {
-                process.stderr.write(`Warning: command "${f.command}" exited with non-zero status code`);
-            });
-            return false;
+            const output = failed
+                .map((f) => `Warning: command "${f.command}" exited with non-zero status code`)
+                .join('\r\n');
+            terminalOutput += output;
+            if (options.streamOutput) {
+                process.stderr.write(output);
+            }
+            return {
+                success: false,
+                terminalOutput,
+            };
         }
         else {
-            return true;
+            return {
+                success: true,
+                terminalOutput,
+            };
         }
     }
 }
@@ -118,46 +136,53 @@ function normalizeOptions(options) {
     return options;
 }
 async function runSerially(options, context) {
+    let terminalOutput = '';
     for (const c of options.commands) {
-        const success = await createProcess(c, undefined, options.color, calculateCwd(options.cwd, context), options.env ?? {}, false);
-        if (!success) {
-            process.stderr.write(`Warning: command "${c.command}" exited with non-zero status code`);
-            return false;
+        const result = await createProcess(c, undefined, options.color, calculateCwd(options.cwd, context), options.env ?? {}, false, options.usePty, options.streamOutput);
+        terminalOutput += result.terminalOutput;
+        if (!result.success) {
+            const output = `Warning: command "${c.command}" exited with non-zero status code`;
+            result.terminalOutput += output;
+            if (options.streamOutput) {
+                process.stderr.write(output);
+            }
+            return { success: false, terminalOutput };
         }
     }
-    return true;
+    return { success: true, terminalOutput };
 }
-async function createProcess(commandConfig, readyWhen, color, cwd, env, isParallel) {
+async function createProcess(commandConfig, readyWhen, color, cwd, env, isParallel, usePty = true, streamOutput = true) {
     env = processEnv(color, cwd, env);
     // The rust runCommand is always a tty, so it will not look nice in parallel and if we need prefixes
     // currently does not work properly in windows
     if (process.env.NX_NATIVE_COMMAND_RUNNER !== 'false' &&
         process.stdout.isTTY &&
         !commandConfig.prefix &&
-        !isParallel) {
-        const cp = new child_process_2.PseudoTtyProcess((0, native_1.runCommand)(commandConfig.command, cwd, env));
+        !isParallel &&
+        usePty) {
+        const cp = new child_process_2.PseudoTtyProcess((0, native_1.runCommand)(commandConfig.command, cwd, env, !streamOutput));
+        let terminalOutput = '';
         return new Promise((res) => {
             cp.onOutput((output) => {
+                terminalOutput += output;
                 if (readyWhen && output.indexOf(readyWhen) > -1) {
-                    res(true);
+                    res({ success: true, terminalOutput });
                 }
             });
             cp.onExit((code) => {
-                if (code === 0) {
-                    res(true);
-                }
-                else if (code >= 128) {
+                if (code >= 128) {
                     process.exit(code);
                 }
                 else {
-                    res(false);
+                    res({ success: code === 0, terminalOutput });
                 }
             });
         });
     }
-    return nodeProcess(commandConfig, color, cwd, env, readyWhen);
+    return nodeProcess(commandConfig, cwd, env, readyWhen, streamOutput);
 }
-function nodeProcess(commandConfig, color, cwd, env, readyWhen) {
+function nodeProcess(commandConfig, cwd, env, readyWhen, streamOutput = true) {
+    let terminalOutput = '';
     return new Promise((res) => {
         const childProcess = (0, child_process_1.exec)(commandConfig.command, {
             maxBuffer: exports.LARGE_BUFFER,
@@ -173,24 +198,36 @@ function nodeProcess(commandConfig, color, cwd, env, readyWhen) {
         process.on('SIGINT', processExitListener);
         process.on('SIGQUIT', processExitListener);
         childProcess.stdout.on('data', (data) => {
-            process.stdout.write(addColorAndPrefix(data, commandConfig));
+            const output = addColorAndPrefix(data, commandConfig);
+            terminalOutput += output;
+            if (streamOutput) {
+                process.stdout.write(output);
+            }
             if (readyWhen && data.toString().indexOf(readyWhen) > -1) {
-                res(true);
+                res({ success: true, terminalOutput });
             }
         });
         childProcess.stderr.on('data', (err) => {
-            process.stderr.write(addColorAndPrefix(err, commandConfig));
+            const output = addColorAndPrefix(err, commandConfig);
+            terminalOutput += output;
+            if (streamOutput) {
+                process.stderr.write(output);
+            }
             if (readyWhen && err.toString().indexOf(readyWhen) > -1) {
-                res(true);
+                res({ success: true, terminalOutput });
             }
         });
         childProcess.on('error', (err) => {
-            process.stderr.write(addColorAndPrefix(err.toString(), commandConfig));
-            res(false);
+            const ouptput = addColorAndPrefix(err.toString(), commandConfig);
+            terminalOutput += ouptput;
+            if (streamOutput) {
+                process.stderr.write(ouptput);
+            }
+            res({ success: false, terminalOutput });
         });
         childProcess.on('exit', (code) => {
             if (!readyWhen) {
-                res(code === 0);
+                res({ success: code === 0, terminalOutput });
             }
         });
     });
@@ -218,11 +255,13 @@ function calculateCwd(cwd, context) {
     return path.join(context.root, cwd);
 }
 function processEnv(color, cwd, env) {
+    const localEnv = (0, npm_run_path_1.env)({ cwd: cwd ?? process.cwd() });
     const res = {
         ...process.env,
-        ...(0, npm_run_path_1.env)({ cwd: cwd ?? process.cwd() }),
+        ...localEnv,
         ...env,
     };
+    res.PATH = localEnv.PATH; // need to override PATH to make sure we are using the local node_modules
     if (color) {
         res.FORCE_COLOR = `${color}`;
     }

package/src/hasher/hash-task.js

@@ -9,7 +9,7 @@ async function hashTasksThatDoNotDependOnOutputsOfOtherTasks(hasher, projectGrap
     performance.mark('hashMultipleTasks:start');
     const tasks = Object.values(taskGraph.tasks);
     const tasksWithHashers = await Promise.all(tasks.map(async (task) => {
-        const customHasher = await (0, utils_1.getCustomHasher)(task, projectGraph);
+        const customHasher = (0, utils_1.getCustomHasher)(task, projectGraph);
         return { task, customHasher };
     }));
     const tasksToHash = tasksWithHashers
@@ -33,7 +33,7 @@ async function hashTasksThatDoNotDependOnOutputsOfOtherTasks(hasher, projectGrap
 exports.hashTasksThatDoNotDependOnOutputsOfOtherTasks = hashTasksThatDoNotDependOnOutputsOfOtherTasks;
 async function hashTask(hasher, projectGraph, taskGraph, task, env) {
     performance.mark('hashSingleTask:start');
-    const customHasher = await (0, utils_1.getCustomHasher)(task, projectGraph);
+    const customHasher = (0, utils_1.getCustomHasher)(task, projectGraph);
     const projectsConfigurations = (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph);
     const { value, details } = await (customHasher
         ? customHasher(task, {

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

@@ -3,6 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TaskOrchestrator = void 0;
 const events_1 = require("events");
 const perf_hooks_1 = require("perf_hooks");
+const path_1 = require("path");
+const run_commands_impl_1 = require("../executors/run-commands/run-commands.impl");
 const forked_process_task_runner_1 = require("./forked-process-task-runner");
 const cache_1 = require("./cache");
 const utils_1 = require("./utils");
@@ -10,6 +12,9 @@ const tasks_schedule_1 = require("./tasks-schedule");
 const hash_task_1 = require("../hasher/hash-task");
 const task_env_1 = require("./task-env");
 const os = require("os");
+const workspace_root_1 = require("../utils/workspace-root");
+const output_1 = require("../utils/output");
+const params_1 = require("../utils/params");
 class TaskOrchestrator {
     // endregion internal state
     constructor(hasher, initiatingProject, projectGraph, taskGraph, options, bail, daemon) {
@@ -205,13 +210,45 @@ class TaskOrchestrator {
         let results = doNotSkipCache ? await this.applyCachedResults([task]) : [];
         // the task wasn't cached
         if (results.length === 0) {
-            // cache prep
-            const { code, terminalOutput } = await this.runTaskInForkedProcess(task, env, pipeOutput, temporaryOutputPath, streamOutput);
-            results.push({
-                task,
-                status: code === 0 ? 'success' : 'failure',
-                terminalOutput,
-            });
+            const shouldPrefix = streamOutput && process.env.NX_PREFIX_OUTPUT === 'true';
+            const targetConfiguration = (0, utils_1.getTargetConfigurationForTask)(task, this.projectGraph);
+            if (process.env.NX_RUN_COMMANDS_DIRECTLY !== 'false' &&
+                targetConfiguration.executor === 'nx:run-commands' &&
+                !shouldPrefix) {
+                const { schema } = (0, utils_1.getExecutorForTask)(task, this.projectGraph);
+                const isRunOne = this.initiatingProject != null;
+                const combinedOptions = (0, params_1.combineOptionsForExecutor)(task.overrides, task.target.configuration ?? targetConfiguration.defaultConfiguration, targetConfiguration, schema, task.target.project, (0, path_1.relative)(task.projectRoot ?? workspace_root_1.workspaceRoot, process.cwd()), process.env.NX_VERBOSE_LOGGING === 'true');
+                if (streamOutput) {
+                    const args = (0, utils_1.getPrintableCommandArgsForTask)(task);
+                    output_1.output.logCommand(args.join(' '));
+                }
+                const { success, terminalOutput } = await (0, run_commands_impl_1.default)({
+                    ...combinedOptions,
+                    env,
+                    usePty: isRunOne && !this.tasksSchedule.hasTasks(),
+                    streamOutput,
+                }, {
+                    root: workspace_root_1.workspaceRoot, // only root is needed in runCommandsImpl
+                });
+                const status = success ? 'success' : 'failure';
+                if (!streamOutput) {
+                    this.options.lifeCycle.printTaskTerminalOutput(task, status, terminalOutput);
+                }
+                results.push({
+                    task,
+                    status,
+                    terminalOutput,
+                });
+            }
+            else {
+                // cache prep
+                const { code, terminalOutput } = await this.runTaskInForkedProcess(task, env, pipeOutput, temporaryOutputPath, streamOutput);
+                results.push({
+                    task,
+                    status: code === 0 ? 'success' : 'failure',
+                    terminalOutput,
+                });
+            }
         }
         await this.postRunSteps([task], results, doNotSkipCache, { groupId });
     }
@@ -338,7 +375,7 @@ class TaskOrchestrator {
             if (process.env.NX_NATIVE_COMMAND_RUNNER !== 'false') {
                 return true;
             }
-            const { schema } = await (0, utils_1.getExecutorForTask)(task, this.projectGraph);
+            const { schema } = (0, utils_1.getExecutorForTask)(task, this.projectGraph);
             return (schema.outputCapture === 'pipe' ||
                 process.env.NX_STREAM_OUTPUT === 'true');
         }

package/src/tasks-runner/tasks-schedule.js

@@ -89,7 +89,7 @@ class TasksSchedule {
         const batchMap = {};
         for (const root of this.notScheduledTaskGraph.roots) {
             const rootTask = this.notScheduledTaskGraph.tasks[root];
-            const executorName = await (0, utils_1.getExecutorNameForTask)(rootTask, this.projectGraph);
+            const executorName = (0, utils_1.getExecutorNameForTask)(rootTask, this.projectGraph);
             await this.processTaskForBatches(batchMap, rootTask, executorName, true);
         }
         for (const [executorName, taskGraph] of Object.entries(batchMap)) {
@@ -105,8 +105,8 @@ class TasksSchedule {
         if (!this.canBatchTaskBeScheduled(task.id, batches[rootExecutorName])) {
             return;
         }
-        const { batchImplementationFactory } = await (0, utils_1.getExecutorForTask)(task, this.projectGraph);
-        const executorName = await (0, utils_1.getExecutorNameForTask)(task, this.projectGraph);
+        const { batchImplementationFactory } = (0, utils_1.getExecutorForTask)(task, this.projectGraph);
+        const executorName = (0, utils_1.getExecutorNameForTask)(task, this.projectGraph);
         if (rootExecutorName !== executorName) {
             return;
         }

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

@@ -1,7 +1,7 @@
 import { Task, TaskGraph } from '../config/task-graph';
 import { ProjectGraph, ProjectGraphProjectNode } from '../config/project-graph';
-import { TargetDependencyConfig } from '../config/workspace-json-project-json';
-import { CustomHasher } from '../config/misc-interfaces';
+import { TargetConfiguration, TargetDependencyConfig } from '../config/workspace-json-project-json';
+import { CustomHasher, ExecutorConfig } from '../config/misc-interfaces';
 export declare function getCommandAsString(execCommand: string, task: Task): string;
 export declare function getDependencyConfigs({ project, target }: {
     project: string;
@@ -23,12 +23,13 @@ export declare function transformLegacyOutputs(projectRoot: string, error: Inval
 export declare function getOutputsForTargetAndConfiguration(task: Task, node: ProjectGraphProjectNode): string[];
 export declare function getOutputsForTargetAndConfiguration(target: Task['target'] | Task, overrides: Task['overrides'] | ProjectGraphProjectNode, node: ProjectGraphProjectNode): string[];
 export declare function interpolate(template: string, data: any): string;
-export declare function getExecutorNameForTask(task: Task, projectGraph: ProjectGraph): Promise<string>;
-export declare function getExecutorForTask(task: Task, projectGraph: ProjectGraph): Promise<import("../config/misc-interfaces").ExecutorConfig & {
+export declare function getTargetConfigurationForTask(task: Task, projectGraph: ProjectGraph): TargetConfiguration | undefined;
+export declare function getExecutorNameForTask(task: Task, projectGraph: ProjectGraph): string;
+export declare function getExecutorForTask(task: Task, projectGraph: ProjectGraph): ExecutorConfig & {
     isNgCompat: boolean;
     isNxExecutor: boolean;
-}>;
-export declare function getCustomHasher(task: Task, projectGraph: ProjectGraph): Promise<CustomHasher> | null;
+};
+export declare function getCustomHasher(task: Task, projectGraph: ProjectGraph): CustomHasher | null;
 export declare function removeTasksFromTaskGraph(graph: TaskGraph, ids: string[]): TaskGraph;
 export declare function removeIdsFromGraph<T>(graph: {
     roots: string[];

package/src/tasks-runner/utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.unparse = exports.isCacheableTask = exports.shouldStreamOutput = exports.getSerializedArgsForTask = exports.getPrintableCommandArgsForTask = exports.getCliPath = exports.calculateReverseDeps = exports.removeIdsFromGraph = exports.removeTasksFromTaskGraph = exports.getCustomHasher = exports.getExecutorForTask = exports.getExecutorNameForTask = exports.interpolate = exports.getOutputsForTargetAndConfiguration = exports.transformLegacyOutputs = exports.validateOutputs = exports.getOutputs = exports.expandDependencyConfigSyntaxSugar = exports.getDependencyConfigs = exports.getCommandAsString = void 0;
+exports.unparse = exports.isCacheableTask = exports.shouldStreamOutput = exports.getSerializedArgsForTask = exports.getPrintableCommandArgsForTask = exports.getCliPath = exports.calculateReverseDeps = exports.removeIdsFromGraph = exports.removeTasksFromTaskGraph = exports.getCustomHasher = exports.getExecutorForTask = exports.getExecutorNameForTask = exports.getTargetConfigurationForTask = exports.interpolate = exports.getOutputsForTargetAndConfiguration = exports.transformLegacyOutputs = exports.validateOutputs = exports.getOutputs = exports.expandDependencyConfigSyntaxSugar = exports.getDependencyConfigs = exports.getCommandAsString = void 0;
 const output_1 = require("../utils/output");
 const path_1 = require("path");
 const workspace_root_1 = require("../utils/workspace-root");
@@ -177,19 +177,23 @@ function interpolate(template, data) {
     });
 }
 exports.interpolate = interpolate;
-async function getExecutorNameForTask(task, projectGraph) {
+function getTargetConfigurationForTask(task, projectGraph) {
     const project = projectGraph.nodes[task.target.project].data;
-    return project.targets[task.target.target].executor;
+    return project.targets[task.target.target];
+}
+exports.getTargetConfigurationForTask = getTargetConfigurationForTask;
+function getExecutorNameForTask(task, projectGraph) {
+    return getTargetConfigurationForTask(task, projectGraph)?.executor;
 }
 exports.getExecutorNameForTask = getExecutorNameForTask;
-async function getExecutorForTask(task, projectGraph) {
-    const executor = await getExecutorNameForTask(task, projectGraph);
+function getExecutorForTask(task, projectGraph) {
+    const executor = getExecutorNameForTask(task, projectGraph);
     const [nodeModule, executorName] = executor.split(':');
     return (0, executor_utils_1.getExecutorInformation)(nodeModule, executorName, workspace_root_1.workspaceRoot, (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph).projects);
 }
 exports.getExecutorForTask = getExecutorForTask;
-async function getCustomHasher(task, projectGraph) {
-    const factory = (await getExecutorForTask(task, projectGraph)).hasherFactory;
+function getCustomHasher(task, projectGraph) {
+    const factory = getExecutorForTask(task, projectGraph).hasherFactory;
     return factory ? factory() : null;
 }
 exports.getCustomHasher = getCustomHasher;

package/src/utils/output.js

@@ -181,7 +181,7 @@ class CLIOutput {
     getStatusIcon(taskStatus) {
         switch (taskStatus) {
             case 'success':
-                return '✔️';
+                return '✅';
             case 'failure':
                 return '❌';
             case 'skipped':