nx 19.8.1 → 19.8.3

package/src/daemon/cache.d.ts

@@ -2,9 +2,8 @@ export interface DaemonProcessJson {
     processId: number;
 }
 export declare const serverProcessJsonPath: string;
-export declare function readDaemonProcessJsonCache(): Promise<DaemonProcessJson | null>;
+export declare function readDaemonProcessJsonCache(): DaemonProcessJson | null;
 export declare function deleteDaemonJsonProcessCache(): void;
 export declare function writeDaemonJsonProcessCache(daemonJson: DaemonProcessJson): Promise<void>;
 export declare function waitForDaemonToExitAndCleanupProcessJson(): Promise<void>;
-export declare function safelyCleanUpExistingProcess(): Promise<void>;
 export declare function getDaemonProcessIdSync(): number | null;

package/src/daemon/cache.js

@@ -5,31 +5,33 @@ exports.readDaemonProcessJsonCache = readDaemonProcessJsonCache;
 exports.deleteDaemonJsonProcessCache = deleteDaemonJsonProcessCache;
 exports.writeDaemonJsonProcessCache = writeDaemonJsonProcessCache;
 exports.waitForDaemonToExitAndCleanupProcessJson = waitForDaemonToExitAndCleanupProcessJson;
-exports.safelyCleanUpExistingProcess = safelyCleanUpExistingProcess;
 exports.getDaemonProcessIdSync = getDaemonProcessIdSync;
-const fs_extra_1 = require("fs-extra");
+const node_fs_1 = require("node:fs");
 const path_1 = require("path");
 const tmp_dir_1 = require("./tmp-dir");
+const fileutils_1 = require("../utils/fileutils");
 exports.serverProcessJsonPath = (0, path_1.join)(tmp_dir_1.DAEMON_DIR_FOR_CURRENT_WORKSPACE, 'server-process.json');
-async function readDaemonProcessJsonCache() {
-    if (!(0, fs_extra_1.existsSync)(exports.serverProcessJsonPath)) {
+function readDaemonProcessJsonCache() {
+    if (!(0, node_fs_1.existsSync)(exports.serverProcessJsonPath)) {
         return null;
     }
-    return await (0, fs_extra_1.readJson)(exports.serverProcessJsonPath);
+    return (0, fileutils_1.readJsonFile)(exports.serverProcessJsonPath);
 }
 function deleteDaemonJsonProcessCache() {
     try {
         if (getDaemonProcessIdSync() === process.pid) {
-            (0, fs_extra_1.unlinkSync)(exports.serverProcessJsonPath);
+            (0, node_fs_1.unlinkSync)(exports.serverProcessJsonPath);
         }
     }
     catch { }
 }
 async function writeDaemonJsonProcessCache(daemonJson) {
-    await (0, fs_extra_1.writeJson)(exports.serverProcessJsonPath, daemonJson);
+    await (0, fileutils_1.writeJsonFileAsync)(exports.serverProcessJsonPath, daemonJson, {
+        appendNewLine: true,
+    });
 }
 async function waitForDaemonToExitAndCleanupProcessJson() {
-    const daemonProcessJson = await readDaemonProcessJsonCache();
+    const daemonProcessJson = readDaemonProcessJsonCache();
     if (daemonProcessJson && daemonProcessJson.processId) {
         await new Promise((resolve, reject) => {
             let count = 0;
@@ -51,24 +53,13 @@ async function waitForDaemonToExitAndCleanupProcessJson() {
         deleteDaemonJsonProcessCache();
     }
 }
-async function safelyCleanUpExistingProcess() {
-    const daemonProcessJson = await readDaemonProcessJsonCache();
-    if (daemonProcessJson && daemonProcessJson.processId) {
-        try {
-            process.kill(daemonProcessJson.processId);
-            // we wait for the process to actually shut down before returning
-            await waitForDaemonToExitAndCleanupProcessJson();
-        }
-        catch { }
-    }
-}
 // Must be sync for the help output use case
 function getDaemonProcessIdSync() {
-    if (!(0, fs_extra_1.existsSync)(exports.serverProcessJsonPath)) {
+    if (!(0, node_fs_1.existsSync)(exports.serverProcessJsonPath)) {
         return null;
     }
     try {
-        const daemonProcessJson = (0, fs_extra_1.readJsonSync)(exports.serverProcessJsonPath);
+        const daemonProcessJson = (0, fileutils_1.readJsonFile)(exports.serverProcessJsonPath);
         return daemonProcessJson.processId;
     }
     catch {

package/src/daemon/client/client.js

@@ -4,9 +4,8 @@ exports.daemonClient = exports.DaemonClient = void 0;
 exports.isDaemonEnabled = isDaemonEnabled;
 const workspace_root_1 = require("../../utils/workspace-root");
 const child_process_1 = require("child_process");
-const fs_1 = require("fs");
+const node_fs_1 = require("node:fs");
 const promises_1 = require("fs/promises");
-const fs_extra_1 = require("fs-extra");
 const net_1 = require("net");
 const path_1 = require("path");
 const perf_hooks_1 = require("perf_hooks");
@@ -409,8 +408,10 @@ class DaemonClient {
         }
     }
     async startInBackground() {
-        (0, fs_extra_1.ensureDirSync)(tmp_dir_1.DAEMON_DIR_FOR_CURRENT_WORKSPACE);
-        (0, fs_extra_1.ensureFileSync)(tmp_dir_1.DAEMON_OUTPUT_LOG_FILE);
+        (0, node_fs_1.mkdirSync)(tmp_dir_1.DAEMON_DIR_FOR_CURRENT_WORKSPACE, { recursive: true });
+        if (!(0, node_fs_1.existsSync)(tmp_dir_1.DAEMON_OUTPUT_LOG_FILE)) {
+            (0, node_fs_1.writeFileSync)(tmp_dir_1.DAEMON_OUTPUT_LOG_FILE, '');
+        }
         this._out = await (0, promises_1.open)(tmp_dir_1.DAEMON_OUTPUT_LOG_FILE, 'a');
         this._err = await (0, promises_1.open)(tmp_dir_1.DAEMON_OUTPUT_LOG_FILE, 'a');
         const backgroundProcess = (0, child_process_1.spawn)(process.execPath, [(0, path_1.join)(__dirname, `../server/start.js`)], {
@@ -454,7 +455,7 @@ class DaemonClient {
         catch (err) {
             output_1.output.error({
                 title: err?.message ||
-                    'Something unexpected went wrong when stopping the server',
+                    'Something unexpected went wrong when stopping the daemon server',
             });
         }
         (0, tmp_dir_1.removeSocketDir)();
@@ -467,12 +468,12 @@ function isDaemonEnabled() {
 }
 function isDocker() {
     try {
-        (0, fs_1.statSync)('/.dockerenv');
+        (0, node_fs_1.statSync)('/.dockerenv');
         return true;
     }
     catch {
         try {
-            return (0, fs_1.readFileSync)('/proc/self/cgroup', 'utf8')?.includes('docker');
+            return (0, node_fs_1.readFileSync)('/proc/self/cgroup', 'utf8')?.includes('docker');
         }
         catch { }
         return false;
@@ -483,7 +484,7 @@ function nxJsonIsNotPresent() {
 }
 function daemonProcessException(message) {
     try {
-        let log = (0, fs_1.readFileSync)(tmp_dir_1.DAEMON_OUTPUT_LOG_FILE).toString().split('\n');
+        let log = (0, node_fs_1.readFileSync)(tmp_dir_1.DAEMON_OUTPUT_LOG_FILE).toString().split('\n');
         if (log.length > 20) {
             log = log.slice(log.length - 20);
         }

package/src/daemon/tmp-dir.js

@@ -11,8 +11,7 @@ exports.removeSocketDir = removeSocketDir;
  * location within the OS's tmp directory where we write log files for background processes
  * and where we create the actual unix socket/named pipe for the daemon.
  */
-const fs_1 = require("fs");
-const fs_extra_1 = require("fs-extra");
+const node_fs_1 = require("node:fs");
 const path_1 = require("path");
 const cache_directory_1 = require("../utils/cache-directory");
 const crypto_1 = require("crypto");
@@ -26,15 +25,15 @@ const getDaemonSocketDir = () => (0, path_1.join)(getSocketDir(),
 exports.getDaemonSocketDir = getDaemonSocketDir;
 function writeDaemonLogs(error) {
     const file = (0, path_1.join)(exports.DAEMON_DIR_FOR_CURRENT_WORKSPACE, 'daemon-error.log');
-    (0, fs_1.writeFileSync)(file, error);
+    (0, node_fs_1.writeFileSync)(file, error);
     return file;
 }
 function markDaemonAsDisabled() {
-    (0, fs_1.writeFileSync)((0, path_1.join)(exports.DAEMON_DIR_FOR_CURRENT_WORKSPACE, 'disabled'), 'true');
+    (0, node_fs_1.writeFileSync)((0, path_1.join)(exports.DAEMON_DIR_FOR_CURRENT_WORKSPACE, 'disabled'), 'true');
 }
 function isDaemonDisabled() {
     try {
-        (0, fs_1.statSync)((0, path_1.join)(exports.DAEMON_DIR_FOR_CURRENT_WORKSPACE, 'disabled'));
+        (0, node_fs_1.statSync)((0, path_1.join)(exports.DAEMON_DIR_FOR_CURRENT_WORKSPACE, 'disabled'));
         return true;
     }
     catch (e) {
@@ -56,7 +55,7 @@ function getSocketDir(alreadyUnique = false) {
         const dir = process.env.NX_SOCKET_DIR ??
             process.env.NX_DAEMON_SOCKET_DIR ??
             (alreadyUnique ? tmp_1.tmpdir : socketDirName());
-        (0, fs_extra_1.ensureDirSync)(dir);
+        (0, node_fs_1.mkdirSync)(dir, { recursive: true });
         return dir;
     }
     catch (e) {
@@ -65,7 +64,7 @@ function getSocketDir(alreadyUnique = false) {
 }
 function removeSocketDir() {
     try {
-        (0, fs_extra_1.rmSync)(getSocketDir(), { recursive: true, force: true });
+        (0, node_fs_1.rmSync)(getSocketDir(), { recursive: true, force: true });
     }
     catch (e) { }
 }

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

@@ -16,22 +16,11 @@ let pseudoTerminal;
 const childProcesses = new Set();
 function loadEnvVarsFile(path, env = {}) {
     (0, task_env_1.unloadDotEnvFile)(path, env);
-    const result = (0, task_env_1.loadAndExpandDotEnvFile)(path, env, true);
+    const result = (0, task_env_1.loadAndExpandDotEnvFile)(path, env);
     if (result.error) {
         throw result.error;
     }
 }
-function loadEnvVars(path, env = {}) {
-    if (path) {
-        loadEnvVarsFile(path, env);
-    }
-    else {
-        try {
-            loadEnvVarsFile('.env', env);
-        }
-        catch { }
-    }
-}
 const propKeys = [
     'command',
     'commands',
@@ -292,20 +281,24 @@ function calculateCwd(cwd, context) {
         return cwd;
     return path.join(context.root, cwd);
 }
-function processEnv(color, cwd, env, envFile) {
-    const localEnv = (0, npm_run_path_1.env)({ cwd: cwd ?? process.cwd() });
-    let res = {
+/**
+ * Env variables are processed in the following order:
+ * - env option from executor options
+ * - env file from envFile option if provided
+ * - local env variables
+ */
+function processEnv(color, cwd, envOptionFromExecutor, envFile) {
+    let localEnv = (0, npm_run_path_1.env)({ cwd: cwd ?? process.cwd() });
+    localEnv = {
         ...process.env,
         ...localEnv,
     };
-    // env file from envFile option takes priority over process env
-    if (process.env.NX_LOAD_DOT_ENV_FILES !== 'false') {
-        loadEnvVars(envFile, res);
+    if (process.env.NX_LOAD_DOT_ENV_FILES !== 'false' && envFile) {
+        loadEnvVarsFile(envFile, localEnv);
     }
-    // env variables from env option takes priority over everything else
-    res = {
-        ...res,
-        ...env,
+    let res = {
+        ...localEnv,
+        ...envOptionFromExecutor,
     };
     // need to override PATH to make sure we are using the local node_modules
     if (localEnv.PATH)

package/src/generators/tree.d.ts

@@ -1,4 +1,4 @@
-import type { Mode } from 'fs';
+import type { Mode } from 'node:fs';
 /**
  * Options to set when writing a file in the Virtual file system tree.
  */

package/src/generators/tree.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.FsTree = void 0;
 exports.flushChanges = flushChanges;
 exports.printChanges = printChanges;
-const fs_extra_1 = require("fs-extra");
+const node_fs_1 = require("node:fs");
 const logger_1 = require("../utils/logger");
 const output_1 = require("../utils/output");
 const path_1 = require("path");
@@ -228,22 +228,22 @@ class FsTree {
     }
     fsReadDir(dirPath) {
         try {
-            return (0, fs_extra_1.readdirSync)((0, path_1.join)(this.root, dirPath));
+            return (0, node_fs_1.readdirSync)((0, path_1.join)(this.root, dirPath));
         }
         catch {
             return [];
         }
     }
     fsIsFile(filePath) {
-        const stat = (0, fs_extra_1.statSync)((0, path_1.join)(this.root, filePath));
+        const stat = (0, node_fs_1.statSync)((0, path_1.join)(this.root, filePath));
         return stat.isFile();
     }
     fsReadFile(filePath) {
-        return (0, fs_extra_1.readFileSync)((0, path_1.join)(this.root, filePath));
+        return (0, node_fs_1.readFileSync)((0, path_1.join)(this.root, filePath));
     }
     fsExists(filePath) {
         try {
-            const stat = (0, fs_extra_1.statSync)((0, path_1.join)(this.root, filePath));
+            const stat = (0, node_fs_1.statSync)((0, path_1.join)(this.root, filePath));
             return stat.isFile() || stat.isDirectory();
         }
         catch {
@@ -279,18 +279,18 @@ function flushChanges(root, fileChanges) {
     fileChanges.forEach((f) => {
         const fpath = (0, path_1.join)(root, f.path);
         if (f.type === 'CREATE') {
-            (0, fs_extra_1.ensureDirSync)((0, path_1.dirname)(fpath));
-            (0, fs_extra_1.writeFileSync)(fpath, f.content);
+            (0, node_fs_1.mkdirSync)((0, path_1.dirname)(fpath), { recursive: true });
+            (0, node_fs_1.writeFileSync)(fpath, f.content);
             if (f.options?.mode)
-                (0, fs_extra_1.chmodSync)(fpath, f.options.mode);
+                (0, node_fs_1.chmodSync)(fpath, f.options.mode);
         }
         else if (f.type === 'UPDATE') {
-            (0, fs_extra_1.writeFileSync)(fpath, f.content);
+            (0, node_fs_1.writeFileSync)(fpath, f.content);
             if (f.options?.mode)
-                (0, fs_extra_1.chmodSync)(fpath, f.options.mode);
+                (0, node_fs_1.chmodSync)(fpath, f.options.mode);
         }
         else if (f.type === 'DELETE') {
-            (0, fs_extra_1.removeSync)(fpath);
+            (0, node_fs_1.rmSync)(fpath, { recursive: true, force: true });
         }
     });
 }

package/src/hasher/hash-task.d.ts

@@ -2,5 +2,7 @@ import { Task, TaskGraph } from '../config/task-graph';
 import { TaskHasher } from './task-hasher';
 import { ProjectGraph } from '../config/project-graph';
 import { NxJsonConfiguration } from '../config/nx-json';
-export declare function hashTasksThatDoNotDependOnOutputsOfOtherTasks(hasher: TaskHasher, projectGraph: ProjectGraph, taskGraph: TaskGraph, nxJson: NxJsonConfiguration): Promise<void>;
-export declare function hashTask(hasher: TaskHasher, projectGraph: ProjectGraph, taskGraph: TaskGraph, task: Task, env: NodeJS.ProcessEnv): Promise<void>;
+import { TaskDetails } from '../native';
+export declare function getTaskDetails(): TaskDetails | null;
+export declare function hashTasksThatDoNotDependOnOutputsOfOtherTasks(hasher: TaskHasher, projectGraph: ProjectGraph, taskGraph: TaskGraph, nxJson: NxJsonConfiguration, tasksDetails: TaskDetails | null): Promise<void>;
+export declare function hashTask(hasher: TaskHasher, projectGraph: ProjectGraph, taskGraph: TaskGraph, task: Task, env: NodeJS.ProcessEnv, taskDetails: TaskDetails | null): Promise<void>;

package/src/hasher/hash-task.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTaskDetails = getTaskDetails;
 exports.hashTasksThatDoNotDependOnOutputsOfOtherTasks = hashTasksThatDoNotDependOnOutputsOfOtherTasks;
 exports.hashTask = hashTask;
 const utils_1 = require("../tasks-runner/utils");
@@ -19,9 +20,8 @@ function getTaskDetails() {
     }
     return taskDetails;
 }
-async function hashTasksThatDoNotDependOnOutputsOfOtherTasks(hasher, projectGraph, taskGraph, nxJson) {
+async function hashTasksThatDoNotDependOnOutputsOfOtherTasks(hasher, projectGraph, taskGraph, nxJson, tasksDetails) {
     performance.mark('hashMultipleTasks:start');
-    const taskDetails = getTaskDetails();
     const tasks = Object.values(taskGraph.tasks);
     const tasksWithHashers = await Promise.all(tasks.map(async (task) => {
         const customHasher = (0, utils_1.getCustomHasher)(task, projectGraph);
@@ -42,9 +42,8 @@ async function hashTasksThatDoNotDependOnOutputsOfOtherTasks(hasher, projectGrap
         tasksToHash[i].hash = hashes[i].value;
         tasksToHash[i].hashDetails = hashes[i].details;
     }
-    // TODO: Remove if when sqlite is always on
-    if (taskDetails) {
-        taskDetails.recordTaskDetails(tasksToHash.map((task) => ({
+    if (tasksDetails?.recordTaskDetails) {
+        tasksDetails.recordTaskDetails(tasksToHash.map((task) => ({
             hash: task.hash,
             project: task.target.project,
             target: task.target.target,
@@ -54,9 +53,8 @@ async function hashTasksThatDoNotDependOnOutputsOfOtherTasks(hasher, projectGrap
     performance.mark('hashMultipleTasks:end');
     performance.measure('hashMultipleTasks', 'hashMultipleTasks:start', 'hashMultipleTasks:end');
 }
-async function hashTask(hasher, projectGraph, taskGraph, task, env) {
+async function hashTask(hasher, projectGraph, taskGraph, task, env, taskDetails) {
     performance.mark('hashSingleTask:start');
-    const taskDetails = getTaskDetails();
     const customHasher = (0, utils_1.getCustomHasher)(task, projectGraph);
     const projectsConfigurations = (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph);
     const { value, details } = await (customHasher
@@ -72,8 +70,7 @@ async function hashTask(hasher, projectGraph, taskGraph, task, env) {
         : hasher.hashTask(task, taskGraph, env));
     task.hash = value;
     task.hashDetails = details;
-    // TODO: Remove if when wasm supports sqlite
-    if (taskDetails) {
+    if (taskDetails?.recordTaskDetails) {
         taskDetails.recordTaskDetails([
             {
                 hash: task.hash,

package/src/plugins/js/index.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createDependencies = exports.createNodes = exports.name = void 0;
 const fs_1 = require("fs");
-const fs_extra_1 = require("fs-extra");
 const path_1 = require("path");
 const perf_hooks_1 = require("perf_hooks");
 const cache_directory_1 = require("../../utils/cache-directory");
@@ -96,7 +95,7 @@ function lockFileNeedsReprocessing(lockHash) {
     }
 }
 function writeLastProcessedLockfileHash(hash, lockFile) {
-    (0, fs_extra_1.ensureDirSync)((0, path_1.dirname)(lockFileHashFile));
+    (0, fs_1.mkdirSync)((0, path_1.dirname)(lockFileHashFile), { recursive: true });
     (0, fs_1.writeFileSync)(cachedParsedLockFile, JSON.stringify(lockFile, null, 2));
     (0, fs_1.writeFileSync)(lockFileHashFile, hash);
 }

package/src/project-graph/nx-deps-cache.js

@@ -8,8 +8,7 @@ exports.createProjectFileMapCache = createProjectFileMapCache;
 exports.writeCache = writeCache;
 exports.shouldRecomputeWholeGraph = shouldRecomputeWholeGraph;
 exports.extractCachedFileData = extractCachedFileData;
-const fs_1 = require("fs");
-const fs_extra_1 = require("fs-extra");
+const node_fs_1 = require("node:fs");
 const path_1 = require("path");
 const perf_hooks_1 = require("perf_hooks");
 const cache_directory_1 = require("../utils/cache-directory");
@@ -19,8 +18,8 @@ exports.nxProjectGraph = (0, path_1.join)(cache_directory_1.workspaceDataDirecto
 exports.nxFileMap = (0, path_1.join)(cache_directory_1.workspaceDataDirectory, 'file-map.json');
 function ensureCacheDirectory() {
     try {
-        if (!(0, fs_1.existsSync)(cache_directory_1.workspaceDataDirectory)) {
-            (0, fs_extra_1.ensureDirSync)(cache_directory_1.workspaceDataDirectory);
+        if (!(0, node_fs_1.existsSync)(cache_directory_1.workspaceDataDirectory)) {
+            (0, node_fs_1.mkdirSync)(cache_directory_1.workspaceDataDirectory, { recursive: true });
         }
     }
     catch (e) {
@@ -102,9 +101,9 @@ function writeCache(cache, projectGraph) {
         const tmpFileMapPath = `${exports.nxFileMap}~${unique}`;
         try {
             (0, fileutils_1.writeJsonFile)(tmpProjectGraphPath, projectGraph);
-            (0, fs_extra_1.renameSync)(tmpProjectGraphPath, exports.nxProjectGraph);
+            (0, node_fs_1.renameSync)(tmpProjectGraphPath, exports.nxProjectGraph);
             (0, fileutils_1.writeJsonFile)(tmpFileMapPath, cache);
-            (0, fs_extra_1.renameSync)(tmpFileMapPath, exports.nxFileMap);
+            (0, node_fs_1.renameSync)(tmpFileMapPath, exports.nxFileMap);
             done = true;
         }
         catch (err) {

package/src/tasks-runner/cache.js

@@ -3,11 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Cache = exports.DbCache = void 0;
 exports.getCache = getCache;
 const workspace_root_1 = require("../utils/workspace-root");
-const fs_extra_1 = require("fs-extra");
 const path_1 = require("path");
 const perf_hooks_1 = require("perf_hooks");
 const default_tasks_runner_1 = require("./default-tasks-runner");
 const child_process_1 = require("child_process");
+const node_fs_1 = require("node:fs");
+const promises_1 = require("node:fs/promises");
 const cache_directory_1 = require("../utils/cache-directory");
 const node_machine_id_1 = require("node-machine-id");
 const native_1 = require("../native");
@@ -233,13 +234,13 @@ class Cache {
             // might be left overs from partially-completed cache invocations
             await this.remove(tdCommit);
             await this.remove(td);
-            await (0, fs_extra_1.mkdir)(td);
-            await (0, fs_extra_1.writeFile)((0, path_1.join)(td, 'terminalOutput'), terminalOutput ?? 'no terminal output');
-            await (0, fs_extra_1.mkdir)((0, path_1.join)(td, 'outputs'));
+            await (0, promises_1.mkdir)(td, { recursive: true });
+            await (0, promises_1.writeFile)((0, path_1.join)(td, 'terminalOutput'), terminalOutput ?? 'no terminal output');
+            await (0, promises_1.mkdir)((0, path_1.join)(td, 'outputs'));
             const expandedOutputs = await this.expandOutputsInWorkspace(outputs);
             await Promise.all(expandedOutputs.map(async (f) => {
                 const src = (0, path_1.join)(this.root, f);
-                if (await (0, fs_extra_1.pathExists)(src)) {
+                if ((0, node_fs_1.existsSync)(src)) {
                     const cached = (0, path_1.join)(td, 'outputs', f);
                     await this.copy(src, cached);
                 }
@@ -248,15 +249,15 @@ class Cache {
             // creating this file is atomic, whereas creating a folder is not.
             // so if the process gets terminated while we are copying stuff into cache,
             // the cache entry won't be used.
-            await (0, fs_extra_1.writeFile)((0, path_1.join)(td, 'code'), code.toString());
-            await (0, fs_extra_1.writeFile)((0, path_1.join)(td, 'source'), await this.currentMachineId());
-            await (0, fs_extra_1.writeFile)(tdCommit, 'true');
+            await (0, promises_1.writeFile)((0, path_1.join)(td, 'code'), code.toString());
+            await (0, promises_1.writeFile)((0, path_1.join)(td, 'source'), await this.currentMachineId());
+            await (0, promises_1.writeFile)(tdCommit, 'true');
             if (this.options.remoteCache) {
                 await this.options.remoteCache.store(task.hash, this.cachePath);
             }
             if (terminalOutput) {
                 const outputPath = this.temporaryOutputPath(task);
-                await (0, fs_extra_1.writeFile)(outputPath, terminalOutput);
+                await (0, promises_1.writeFile)(outputPath, terminalOutput);
             }
         });
     }
@@ -265,7 +266,7 @@ class Cache {
             const expandedOutputs = await this.expandOutputsInCache(outputs, cachedResult);
             await Promise.all(expandedOutputs.map(async (f) => {
                 const cached = (0, path_1.join)(cachedResult.outputsPath, f);
-                if (await (0, fs_extra_1.pathExists)(cached)) {
+                if ((0, node_fs_1.existsSync)(cached)) {
                     const src = (0, path_1.join)(this.root, f);
                     await this.remove(src);
                     await this.copy(cached, src);
@@ -321,11 +322,11 @@ class Cache {
     async getFromLocalDir(task) {
         const tdCommit = (0, path_1.join)(this.cachePath, `${task.hash}.commit`);
         const td = (0, path_1.join)(this.cachePath, task.hash);
-        if (await (0, fs_extra_1.pathExists)(tdCommit)) {
-            const terminalOutput = await (0, fs_extra_1.readFile)((0, path_1.join)(td, 'terminalOutput'), 'utf-8');
+        if ((0, node_fs_1.existsSync)(tdCommit)) {
+            const terminalOutput = await (0, promises_1.readFile)((0, path_1.join)(td, 'terminalOutput'), 'utf-8');
             let code = 0;
             try {
-                code = Number(await (0, fs_extra_1.readFile)((0, path_1.join)(td, 'code'), 'utf-8'));
+                code = Number(await (0, promises_1.readFile)((0, path_1.join)(td, 'code'), 'utf-8'));
             }
             catch { }
             return {
@@ -342,7 +343,7 @@ class Cache {
         const td = (0, path_1.join)(this.cachePath, task.hash);
         let sourceMachineId = null;
         try {
-            sourceMachineId = await (0, fs_extra_1.readFile)((0, path_1.join)(td, 'source'), 'utf-8');
+            sourceMachineId = await (0, promises_1.readFile)((0, path_1.join)(td, 'source'), 'utf-8');
         }
         catch { }
         if (sourceMachineId && sourceMachineId != (await this.currentMachineId())) {
@@ -361,12 +362,12 @@ class Cache {
         }
     }
     createCacheDir() {
-        (0, fs_extra_1.mkdirSync)(cache_directory_1.cacheDir, { recursive: true });
+        (0, node_fs_1.mkdirSync)(cache_directory_1.cacheDir, { recursive: true });
         return cache_directory_1.cacheDir;
     }
     createTerminalOutputsDir() {
         const path = (0, path_1.join)(this.cachePath, 'terminalOutputs');
-        (0, fs_extra_1.mkdirSync)(path, { recursive: true });
+        (0, node_fs_1.mkdirSync)(path, { recursive: true });
         return path;
     }
 }

package/src/tasks-runner/life-cycles/dynamic-run-many-terminal-output-life-cycle.js

@@ -224,6 +224,11 @@ async function createRunManyDynamicOutputRenderer({ projectNames, tasks, args, o
         clearRenderInterval();
         const timeTakenText = (0, pretty_time_1.prettyTime)(process.hrtime(start));
         moveCursorToStartOfPinnedFooter();
+        if (totalTasks === 0) {
+            renderPinnedFooter([output_1.output.applyNxPrefix('gray', 'No tasks were run')]);
+            resolveRenderIsDonePromise();
+            return;
+        }
         if (totalSuccessfulTasks === totalTasks) {
             const text = `Successfully ran ${(0, formatting_utils_1.formatTargetsAndProjects)(projectNames, targets, tasks)}`;
             const taskOverridesRows = [];

package/src/tasks-runner/life-cycles/static-run-many-terminal-output-life-cycle.js

@@ -23,6 +23,9 @@ class StaticRunManyTerminalOutputLifeCycle {
         this.allCompletedTasks = new Map();
     }
     startCommand() {
+        if (this.tasks.length === 0) {
+            return;
+        }
         if (this.projectNames.length <= 0) {
             output_1.output.logSingleLine(`No projects with ${(0, formatting_utils_1.formatTargetsAndProjects)(this.projectNames, this.args.targets, this.tasks)} were run`);
             return;
@@ -45,6 +48,10 @@ class StaticRunManyTerminalOutputLifeCycle {
     }
     endCommand() {
         output_1.output.addNewline();
+        if (this.tasks.length === 0) {
+            output_1.output.logSingleLine(`No tasks were run`);
+            return;
+        }
         if (this.failedTasks.length === 0) {
             output_1.output.addVerticalSeparatorWithoutNewLines('green');
             const bodyLines = this.cachedTasks.length > 0

package/src/tasks-runner/remove-old-cache-records.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const fs_1 = require("fs");
-const fs_extra_1 = require("fs-extra");
 const path_1 = require("path");
 const WEEK_IN_MS = 1000 * 60 * 60 * 24 * 7;
 const folder = process.argv[2];
@@ -34,11 +33,11 @@ function removeOld(records) {
                 if (time - s.mtimeMs > WEEK_IN_MS) {
                     if (s.isDirectory()) {
                         try {
-                            (0, fs_extra_1.removeSync)(`${r}.commit`);
+                            (0, fs_1.rmSync)(`${r}.commit`, { recursive: true, force: true });
                         }
                         catch (e) { }
                     }
-                    (0, fs_extra_1.removeSync)(r);
+                    (0, fs_1.rmSync)(r, { recursive: true, force: true });
                 }
             }
             catch (e) { }

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

@@ -363,12 +363,14 @@ function setEnvVarsBasedOnArgs(nxArgs, loadDotEnvFiles) {
 }
 async function invokeTasksRunner({ tasks, projectGraph, taskGraph, lifeCycle, nxJson, nxArgs, loadDotEnvFiles, initiatingProject, }) {
     setEnvVarsBasedOnArgs(nxArgs, loadDotEnvFiles);
+    // this needs to be done before we start to run the tasks
+    const taskDetails = (0, hash_task_1.getTaskDetails)();
     const { tasksRunner, runnerOptions } = getRunner(nxArgs, nxJson);
     let hasher = (0, create_task_hasher_1.createTaskHasher)(projectGraph, nxJson, runnerOptions);
     // this is used for two reasons: to fetch all remote cache hits AND
     // to submit everything that is known in advance to Nx Cloud to run in
     // a distributed fashion
-    await (0, hash_task_1.hashTasksThatDoNotDependOnOutputsOfOtherTasks)(hasher, projectGraph, taskGraph, nxJson);
+    await (0, hash_task_1.hashTasksThatDoNotDependOnOutputsOfOtherTasks)(hasher, projectGraph, taskGraph, nxJson, taskDetails);
     const taskResultsLifecycle = new task_results_life_cycle_1.TaskResultsLifeCycle();
     const compositedLifeCycle = new life_cycle_1.CompositeLifeCycle([
         ...constructLifeCycles(lifeCycle),

package/src/tasks-runner/task-orchestrator.d.ts

@@ -15,6 +15,7 @@ export declare class TaskOrchestrator {
     private readonly bail;
     private readonly daemon;
     private readonly outputStyle;
+    private taskDetails;
     private cache;
     private forkedProcessTaskRunner;
     private tasksSchedule;

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

@@ -27,6 +27,7 @@ class TaskOrchestrator {
         this.bail = bail;
         this.daemon = daemon;
         this.outputStyle = outputStyle;
+        this.taskDetails = (0, hash_task_1.getTaskDetails)();
         this.cache = (0, cache_1.getCache)(this.nxJson, this.options);
         this.forkedProcessTaskRunner = new forked_process_task_runner_1.ForkedProcessTaskRunner(this.options);
         this.tasksSchedule = new tasks_schedule_1.TasksSchedule(this.projectGraph, this.taskGraph, this.options);
@@ -93,7 +94,7 @@ class TaskOrchestrator {
         const task = this.taskGraph.tasks[taskId];
         const taskSpecificEnv = (0, task_env_1.getTaskSpecificEnv)(task);
         if (!task.hash) {
-            await (0, hash_task_1.hashTask)(this.hasher, this.projectGraph, this.taskGraph, task, taskSpecificEnv);
+            await (0, hash_task_1.hashTask)(this.hasher, this.projectGraph, this.taskGraph, task, taskSpecificEnv, this.taskDetails);
         }
         await this.options.lifeCycle.scheduleTask(task);
         return taskSpecificEnv;
@@ -101,7 +102,7 @@ class TaskOrchestrator {
     async processScheduledBatch(batch) {
         await Promise.all(Object.values(batch.taskGraph.tasks).map(async (task) => {
             if (!task.hash) {
-                await (0, hash_task_1.hashTask)(this.hasher, this.projectGraph, this.taskGraph, task, this.batchEnv);
+                await (0, hash_task_1.hashTask)(this.hasher, this.projectGraph, this.taskGraph, task, this.batchEnv, this.taskDetails);
             }
             await this.options.lifeCycle.scheduleTask(task);
         }));
@@ -321,6 +322,9 @@ class TaskOrchestrator {
             };
         }
         catch (e) {
+            if (process.env.NX_VERBOSE_LOGGING === 'true') {
+                console.error(e);
+            }
             return {
                 code: 1,
             };