nx 19.4.0-canary.20240622-963f753 → 19.4.0-canary.20240627-c2c6a13

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

@@ -3,116 +3,137 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const messaging_1 = require("./messaging");
 const loader_1 = require("../loader");
 const serializable_error_1 = require("../../../utils/serializable-error");
+const net_1 = require("net");
+const consume_messages_from_socket_1 = require("../../../utils/consume-messages-from-socket");
+const fs_1 = require("fs");
 if (process.env.NX_PERF_LOGGING === 'true') {
     require('../../../utils/perf-logging');
 }
 global.NX_GRAPH_CREATION = true;
 let plugin;
-process.on('message', async (message) => {
-    if (!(0, messaging_1.isPluginWorkerMessage)(message)) {
-        return;
-    }
-    return (0, messaging_1.consumeMessage)(message, {
-        load: async ({ plugin: pluginConfiguration, root }) => {
-            process.chdir(root);
-            try {
-                const [promise] = (0, loader_1.loadNxPlugin)(pluginConfiguration, root);
-                plugin = await promise;
-                return {
-                    type: 'load-result',
-                    payload: {
-                        name: plugin.name,
-                        include: plugin.include,
-                        exclude: plugin.exclude,
-                        createNodesPattern: plugin.createNodes?.[0],
-                        hasCreateDependencies: 'createDependencies' in plugin && !!plugin.createDependencies,
-                        hasProcessProjectGraph: 'processProjectGraph' in plugin && !!plugin.processProjectGraph,
-                        hasCreateMetadata: 'createMetadata' in plugin && !!plugin.createMetadata,
-                        success: true,
-                    },
-                };
-            }
-            catch (e) {
-                return {
-                    type: 'load-result',
-                    payload: {
-                        success: false,
-                        error: (0, serializable_error_1.createSerializableError)(e),
-                    },
-                };
-            }
-        },
-        createNodes: async ({ configFiles, context, tx }) => {
-            try {
-                const result = await plugin.createNodes[1](configFiles, context);
-                return {
-                    type: 'createNodesResult',
-                    payload: { result, success: true, tx },
-                };
-            }
-            catch (e) {
-                return {
-                    type: 'createNodesResult',
-                    payload: {
-                        success: false,
-                        error: (0, serializable_error_1.createSerializableError)(e),
-                        tx,
-                    },
-                };
-            }
-        },
-        createDependencies: async ({ context, tx }) => {
-            try {
-                const result = await plugin.createDependencies(context);
-                return {
-                    type: 'createDependenciesResult',
-                    payload: { dependencies: result, success: true, tx },
-                };
-            }
-            catch (e) {
-                return {
-                    type: 'createDependenciesResult',
-                    payload: {
-                        success: false,
-                        error: (0, serializable_error_1.createSerializableError)(e),
-                        tx,
-                    },
-                };
-            }
-        },
-        processProjectGraph: async ({ graph, ctx, tx }) => {
-            try {
-                const result = await plugin.processProjectGraph(graph, ctx);
-                return {
-                    type: 'processProjectGraphResult',
-                    payload: { graph: result, success: true, tx },
-                };
-            }
-            catch (e) {
-                return {
-                    type: 'processProjectGraphResult',
-                    payload: {
-                        success: false,
-                        error: (0, serializable_error_1.createSerializableError)(e),
-                        tx,
-                    },
-                };
-            }
-        },
-        createMetadata: async ({ graph, context, tx }) => {
-            try {
-                const result = await plugin.createMetadata(graph, context);
-                return {
-                    type: 'createMetadataResult',
-                    payload: { metadata: result, success: true, tx },
-                };
-            }
-            catch (e) {
-                return {
-                    type: 'createMetadataResult',
-                    payload: { success: false, error: e.stack, tx },
-                };
-            }
-        },
-    });
+const socketPath = process.argv[2];
+const server = (0, net_1.createServer)((socket) => {
+    socket.on('data', (0, consume_messages_from_socket_1.consumeMessagesFromSocket)((raw) => {
+        const message = JSON.parse(raw.toString());
+        if (!(0, messaging_1.isPluginWorkerMessage)(message)) {
+            return;
+        }
+        return (0, messaging_1.consumeMessage)(socket, message, {
+            load: async ({ plugin: pluginConfiguration, root }) => {
+                process.chdir(root);
+                try {
+                    const [promise] = (0, loader_1.loadNxPlugin)(pluginConfiguration, root);
+                    plugin = await promise;
+                    return {
+                        type: 'load-result',
+                        payload: {
+                            name: plugin.name,
+                            include: plugin.include,
+                            exclude: plugin.exclude,
+                            createNodesPattern: plugin.createNodes?.[0],
+                            hasCreateDependencies: 'createDependencies' in plugin && !!plugin.createDependencies,
+                            hasProcessProjectGraph: 'processProjectGraph' in plugin &&
+                                !!plugin.processProjectGraph,
+                            hasCreateMetadata: 'createMetadata' in plugin && !!plugin.createMetadata,
+                            success: true,
+                        },
+                    };
+                }
+                catch (e) {
+                    return {
+                        type: 'load-result',
+                        payload: {
+                            success: false,
+                            error: (0, serializable_error_1.createSerializableError)(e),
+                        },
+                    };
+                }
+            },
+            createNodes: async ({ configFiles, context, tx }) => {
+                try {
+                    const result = await plugin.createNodes[1](configFiles, context);
+                    return {
+                        type: 'createNodesResult',
+                        payload: { result, success: true, tx },
+                    };
+                }
+                catch (e) {
+                    return {
+                        type: 'createNodesResult',
+                        payload: {
+                            success: false,
+                            error: (0, serializable_error_1.createSerializableError)(e),
+                            tx,
+                        },
+                    };
+                }
+            },
+            createDependencies: async ({ context, tx }) => {
+                try {
+                    const result = await plugin.createDependencies(context);
+                    return {
+                        type: 'createDependenciesResult',
+                        payload: { dependencies: result, success: true, tx },
+                    };
+                }
+                catch (e) {
+                    return {
+                        type: 'createDependenciesResult',
+                        payload: {
+                            success: false,
+                            error: (0, serializable_error_1.createSerializableError)(e),
+                            tx,
+                        },
+                    };
+                }
+            },
+            processProjectGraph: async ({ graph, ctx, tx }) => {
+                try {
+                    const result = await plugin.processProjectGraph(graph, ctx);
+                    return {
+                        type: 'processProjectGraphResult',
+                        payload: { graph: result, success: true, tx },
+                    };
+                }
+                catch (e) {
+                    return {
+                        type: 'processProjectGraphResult',
+                        payload: {
+                            success: false,
+                            error: (0, serializable_error_1.createSerializableError)(e),
+                            tx,
+                        },
+                    };
+                }
+            },
+            createMetadata: async ({ graph, context, tx }) => {
+                try {
+                    const result = await plugin.createMetadata(graph, context);
+                    return {
+                        type: 'createMetadataResult',
+                        payload: { metadata: result, success: true, tx },
+                    };
+                }
+                catch (e) {
+                    return {
+                        type: 'createMetadataResult',
+                        payload: { success: false, error: e.stack, tx },
+                    };
+                }
+            },
+        });
+    }));
 });
+server.listen(socketPath);
+const exitHandler = (exitCode) => () => {
+    server.close();
+    try {
+        (0, fs_1.unlinkSync)(socketPath);
+    }
+    catch (e) { }
+    process.exit(exitCode);
+};
+const events = ['SIGINT', 'SIGTERM', 'SIGQUIT', 'exit'];
+events.forEach((event) => process.once(event, exitHandler(0)));
+process.once('uncaughtException', exitHandler(1));
+process.once('unhandledRejection', exitHandler(1));

package/src/project-graph/project-graph.js

@@ -110,7 +110,13 @@ async function buildProjectGraphAndSourceMapsWithoutDaemon() {
         }
     }
     finally {
-        cleanup();
+        // When plugins are isolated we don't clean them up during
+        // a single run of the CLI. They are cleaned up when the CLI
+        // process exits. Cleaning them here could cause issues if pending
+        // promises are not resolved.
+        if (process.env.NX_ISOLATE_PLUGINS !== 'true') {
+            cleanup();
+        }
     }
     const { projectGraph, projectFileMapCache } = projectGraphResult;
     perf_hooks_1.performance.mark('build-project-graph-using-project-file-map:end');

package/src/project-graph/utils/project-configuration-utils.js

@@ -293,7 +293,7 @@ function mergeCreateNodesResults(results, errors) {
     const externalNodes = {};
     const configurationSourceMaps = {};
     for (const result of results.flat()) {
-        const [file, pluginName, nodes] = result;
+        const [pluginName, file, nodes] = result;
         const { projects: projectNodes, externalNodes: pluginExternalNodes } = nodes;
         const sourceInfo = [file, pluginName];
         if (result[symbols_1.OVERRIDE_SOURCE_FILE]) {

package/src/project-graph/utils/retrieve-workspace-files.d.ts

@@ -9,12 +9,12 @@ import { LoadedNxPlugin } from '../plugins/internal-api';
  * @param nxJson
  */
 export declare function retrieveWorkspaceFiles(workspaceRoot: string, projectRootMap: Record<string, string>): Promise<{
-    allWorkspaceFiles: import("nx/src/devkit-exports").FileData[];
+    allWorkspaceFiles: import("../file-utils").FileData[];
     fileMap: {
         projectFileMap: ProjectFiles;
-        nonProjectFiles: import("nx/src/native").FileData[];
+        nonProjectFiles: import("../../native").FileData[];
     };
-    rustReferences: import("nx/src/native").NxWorkspaceFilesExternals;
+    rustReferences: import("../../native").NxWorkspaceFilesExternals;
 }>;
 /**
  * Walk through the workspace and return `ProjectConfigurations`. Only use this if the projectFileMap is not needed.

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

@@ -13,12 +13,12 @@ const defaultTasksRunner = async (tasks, options, context) => {
         options['parallel'] === '') {
         options['parallel'] = Number(options['maxParallel'] || 3);
     }
-    options.lifeCycle.startCommand();
+    await options.lifeCycle.startCommand();
     try {
         return await runAllTasks(tasks, options, context);
     }
     finally {
-        options.lifeCycle.endCommand();
+        await options.lifeCycle.endCommand();
     }
 };
 exports.defaultTasksRunner = defaultTasksRunner;

package/src/tasks-runner/life-cycle.d.ts

@@ -10,9 +10,9 @@ export interface TaskMetadata {
     groupId: number;
 }
 export interface LifeCycle {
-    startCommand?(): void;
-    endCommand?(): void;
-    scheduleTask?(task: Task): void;
+    startCommand?(): void | Promise<void>;
+    endCommand?(): void | Promise<void>;
+    scheduleTask?(task: Task): void | Promise<void>;
     /**
      * @deprecated use startTasks
      *
@@ -25,19 +25,19 @@ export interface LifeCycle {
      * endTask won't be supported after Nx 14 is released.
      */
     endTask?(task: Task, code: number): void;
-    startTasks?(task: Task[], metadata: TaskMetadata): void;
-    endTasks?(taskResults: TaskResult[], metadata: TaskMetadata): void;
+    startTasks?(task: Task[], metadata: TaskMetadata): void | Promise<void>;
+    endTasks?(taskResults: TaskResult[], metadata: TaskMetadata): void | Promise<void>;
     printTaskTerminalOutput?(task: Task, status: TaskStatus, output: string): void;
 }
 export declare class CompositeLifeCycle implements LifeCycle {
     private readonly lifeCycles;
     constructor(lifeCycles: LifeCycle[]);
-    startCommand(): void;
-    endCommand(): void;
-    scheduleTask(task: Task): void;
+    startCommand(): Promise<void>;
+    endCommand(): Promise<void>;
+    scheduleTask(task: Task): Promise<void>;
     startTask(task: Task): void;
     endTask(task: Task, code: number): void;
-    startTasks(tasks: Task[], metadata: TaskMetadata): void;
-    endTasks(taskResults: TaskResult[], metadata: TaskMetadata): void;
+    startTasks(tasks: Task[], metadata: TaskMetadata): Promise<void>;
+    endTasks(taskResults: TaskResult[], metadata: TaskMetadata): Promise<void>;
     printTaskTerminalOutput(task: Task, status: TaskStatus, output: string): void;
 }

package/src/tasks-runner/life-cycle.js

@@ -5,24 +5,24 @@ class CompositeLifeCycle {
     constructor(lifeCycles) {
         this.lifeCycles = lifeCycles;
     }
-    startCommand() {
+    async startCommand() {
         for (let l of this.lifeCycles) {
             if (l.startCommand) {
-                l.startCommand();
+                await l.startCommand();
             }
         }
     }
-    endCommand() {
+    async endCommand() {
         for (let l of this.lifeCycles) {
             if (l.endCommand) {
-                l.endCommand();
+                await l.endCommand();
             }
         }
     }
-    scheduleTask(task) {
+    async scheduleTask(task) {
         for (let l of this.lifeCycles) {
             if (l.scheduleTask) {
-                l.scheduleTask(task);
+                await l.scheduleTask(task);
             }
         }
     }
@@ -40,20 +40,20 @@ class CompositeLifeCycle {
             }
         }
     }
-    startTasks(tasks, metadata) {
+    async startTasks(tasks, metadata) {
         for (let l of this.lifeCycles) {
             if (l.startTasks) {
-                l.startTasks(tasks, metadata);
+                await l.startTasks(tasks, metadata);
             }
             else if (l.startTask) {
                 tasks.forEach((t) => l.startTask(t));
             }
         }
     }
-    endTasks(taskResults, metadata) {
+    async endTasks(taskResults, metadata) {
         for (let l of this.lifeCycles) {
             if (l.endTasks) {
-                l.endTasks(taskResults, metadata);
+                await l.endTasks(taskResults, metadata);
             }
             else if (l.endTask) {
                 taskResults.forEach((t) => l.endTask(t.task, t.code));

package/src/tasks-runner/life-cycles/task-history-life-cycle.d.ts

@@ -0,0 +1,9 @@
+import { Task } from '../../config/task-graph';
+import { LifeCycle, TaskResult } from '../life-cycle';
+export declare class TaskHistoryLifeCycle implements LifeCycle {
+    private startTimings;
+    private taskRuns;
+    startTasks(tasks: Task[]): void;
+    endTasks(taskResults: TaskResult[]): Promise<void>;
+    endCommand(): Promise<void>;
+}

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

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskHistoryLifeCycle = void 0;
+const serialize_target_1 = require("../../utils/serialize-target");
+const output_1 = require("../../utils/output");
+const task_history_1 = require("../../utils/task-history");
+class TaskHistoryLifeCycle {
+    constructor() {
+        this.startTimings = {};
+        this.taskRuns = [];
+    }
+    startTasks(tasks) {
+        for (let task of tasks) {
+            this.startTimings[task.id] = new Date().getTime();
+        }
+    }
+    async endTasks(taskResults) {
+        const taskRuns = taskResults.map((taskResult) => ({
+            project: taskResult.task.target.project,
+            target: taskResult.task.target.target,
+            configuration: taskResult.task.target.configuration,
+            hash: taskResult.task.hash,
+            code: taskResult.code.toString(),
+            status: taskResult.status,
+            start: (taskResult.task.startTime ?? this.startTimings[taskResult.task.id]).toString(),
+            end: (taskResult.task.endTime ?? new Date().getTime()).toString(),
+        }));
+        this.taskRuns.push(...taskRuns);
+    }
+    async endCommand() {
+        await (0, task_history_1.writeTaskRunsToHistory)(this.taskRuns);
+        const history = await (0, task_history_1.getHistoryForHashes)(this.taskRuns.map((t) => t.hash));
+        const flakyTasks = [];
+        // check if any hash has different exit codes => flaky
+        for (let hash in history) {
+            if (history[hash].length > 1 &&
+                history[hash].some((run) => run.code !== history[hash][0].code)) {
+                flakyTasks.push((0, serialize_target_1.serializeTarget)(history[hash][0].project, history[hash][0].target, history[hash][0].configuration));
+            }
+        }
+        if (flakyTasks.length > 0) {
+            output_1.output.warn({
+                title: `Nx detected ${flakyTasks.length === 1 ? 'a flaky task' : ' flaky tasks'}`,
+                bodyLines: [
+                    ,
+                    ...flakyTasks.map((t) => `  ${t}`),
+                    '',
+                    `Flaky tasks can disrupt your CI pipeline. Automatically retry them with Nx Cloud. Learn more at https://nx.dev/ci/features/flaky-tasks`,
+                ],
+            });
+        }
+    }
+}
+exports.TaskHistoryLifeCycle = TaskHistoryLifeCycle;

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

@@ -14,6 +14,7 @@ const dynamic_run_many_terminal_output_life_cycle_1 = require("./life-cycles/dyn
 const task_profiling_life_cycle_1 = require("./life-cycles/task-profiling-life-cycle");
 const is_ci_1 = require("../utils/is-ci");
 const dynamic_run_one_terminal_output_life_cycle_1 = require("./life-cycles/dynamic-run-one-terminal-output-life-cycle");
+const nx_json_1 = require("../config/nx-json");
 const create_task_graph_1 = require("./create-task-graph");
 const task_graph_utils_1 = require("./task-graph-utils");
 const params_1 = require("../utils/params");
@@ -21,6 +22,8 @@ const hash_task_1 = require("../hasher/hash-task");
 const client_1 = require("../daemon/client/client");
 const store_run_information_life_cycle_1 = require("./life-cycles/store-run-information-life-cycle");
 const create_task_hasher_1 = require("../hasher/create-task-hasher");
+const task_history_life_cycle_1 = require("./life-cycles/task-history-life-cycle");
+const nx_cloud_utils_1 = require("../utils/nx-cloud-utils");
 async function getTerminalOutputLifeCycle(initiatingProject, projectNames, tasks, nxArgs, nxJson, overrides) {
     const { runnerOptions } = getRunner(nxArgs, nxJson);
     const isRunOne = initiatingProject != null;
@@ -203,6 +206,9 @@ function constructLifeCycles(lifeCycle) {
     if (process.env.NX_PROFILE) {
         lifeCycles.push(new task_profiling_life_cycle_1.TaskProfilingLifeCycle(process.env.NX_PROFILE));
     }
+    if (!(0, nx_cloud_utils_1.isNxCloudUsed)((0, nx_json_1.readNxJson)())) {
+        lifeCycles.push(new task_history_life_cycle_1.TaskHistoryLifeCycle());
+    }
     return lifeCycles;
 }
 function mergeTargetDependencies(defaults, deps) {

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

@@ -6,3 +6,16 @@ export declare function getEnvVariablesForTask(task: Task, taskSpecificEnv: Node
     [x: string]: string;
     TZ?: string;
 };
+/**
+ * This function loads a .env file and expands the variables in it.
+ * It is going to override existing environmentVariables.
+ * @param filename
+ * @param environmentVariables
+ */
+export declare function loadAndExpandDotEnvFile(filename: string, environmentVariables: NodeJS.ProcessEnv, override?: boolean): import("dotenv-expand").DotenvExpandOutput;
+/**
+ * This function unloads a .env file and removes the variables in it from the environmentVariables.
+ * @param filename
+ * @param environmentVariables
+ */
+export declare function unloadDotEnvFile(filename: string, environmentVariables: NodeJS.ProcessEnv, override?: boolean): void;

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getEnvVariablesForTask = exports.getTaskSpecificEnv = exports.getEnvVariablesForBatchProcess = void 0;
+exports.unloadDotEnvFile = exports.loadAndExpandDotEnvFile = exports.getEnvVariablesForTask = exports.getTaskSpecificEnv = exports.getEnvVariablesForBatchProcess = void 0;
 const dotenv_1 = require("dotenv");
 const dotenv_expand_1 = require("dotenv-expand");
 const workspace_root_1 = require("../utils/workspace-root");
@@ -75,9 +75,42 @@ function getNxEnvVariablesForTask(task, forceColor, skipNxCache, captureStderr,
         ...env,
     };
 }
-function loadDotEnvFilesForTask(task, environmentVariables) {
+/**
+ * This function loads a .env file and expands the variables in it.
+ * It is going to override existing environmentVariables.
+ * @param filename
+ * @param environmentVariables
+ */
+function loadAndExpandDotEnvFile(filename, environmentVariables, override = false) {
+    const myEnv = (0, dotenv_1.config)({
+        path: filename,
+        processEnv: environmentVariables,
+        override,
+    });
+    return (0, dotenv_expand_1.expand)({
+        ...myEnv,
+        processEnv: environmentVariables,
+    });
+}
+exports.loadAndExpandDotEnvFile = loadAndExpandDotEnvFile;
+/**
+ * This function unloads a .env file and removes the variables in it from the environmentVariables.
+ * @param filename
+ * @param environmentVariables
+ */
+function unloadDotEnvFile(filename, environmentVariables, override = false) {
+    const parsedDotEnvFile = {};
+    loadAndExpandDotEnvFile(filename, parsedDotEnvFile, override);
+    Object.keys(parsedDotEnvFile).forEach((envVarKey) => {
+        if (environmentVariables[envVarKey] === parsedDotEnvFile[envVarKey]) {
+            delete environmentVariables[envVarKey];
+        }
+    });
+}
+exports.unloadDotEnvFile = unloadDotEnvFile;
+function getEnvFilesForTask(task) {
     // Collect dot env files that may pertain to a task
-    const dotEnvFiles = [
+    return [
         // Load DotEnv Files for a configuration in the project root
         ...(task.target.configuration
             ? [
@@ -122,35 +155,17 @@ function loadDotEnvFilesForTask(task, environmentVariables) {
         `.env.local`,
         `.env`,
     ];
+}
+function loadDotEnvFilesForTask(task, environmentVariables) {
+    const dotEnvFiles = getEnvFilesForTask(task);
     for (const file of dotEnvFiles) {
-        const myEnv = (0, dotenv_1.config)({
-            path: file,
-            processEnv: environmentVariables,
-            // Do not override existing env variables as we load
-            override: false,
-        });
-        environmentVariables = {
-            ...(0, dotenv_expand_1.expand)({
-                ...myEnv,
-                ignoreProcessEnv: true, // Do not override existing env variables as we load
-            }).parsed,
-            ...environmentVariables,
-        };
+        loadAndExpandDotEnvFile(file, environmentVariables);
     }
     return environmentVariables;
 }
 function unloadDotEnvFiles(environmentVariables) {
-    const unloadDotEnvFile = (filename) => {
-        let parsedDotEnvFile = {};
-        (0, dotenv_1.config)({ path: filename, processEnv: parsedDotEnvFile });
-        Object.keys(parsedDotEnvFile).forEach((envVarKey) => {
-            if (environmentVariables[envVarKey] === parsedDotEnvFile[envVarKey]) {
-                delete environmentVariables[envVarKey];
-            }
-        });
-    };
     for (const file of ['.env', '.local.env', '.env.local']) {
-        unloadDotEnvFile(file);
+        unloadDotEnvFile(file, environmentVariables);
     }
     return environmentVariables;
 }

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

@@ -88,7 +88,7 @@ class TaskOrchestrator {
         if (!task.hash) {
             await (0, hash_task_1.hashTask)(this.hasher, this.projectGraph, this.taskGraph, task, taskSpecificEnv);
         }
-        this.options.lifeCycle.scheduleTask(task);
+        await this.options.lifeCycle.scheduleTask(task);
         return taskSpecificEnv;
     }
     async processScheduledBatch(batch) {
@@ -96,7 +96,7 @@ class TaskOrchestrator {
             if (!task.hash) {
                 await (0, hash_task_1.hashTask)(this.hasher, this.projectGraph, this.taskGraph, task, this.batchEnv);
             }
-            this.options.lifeCycle.scheduleTask(task);
+            await this.options.lifeCycle.scheduleTask(task);
         }));
     }
     processAllScheduledTasks() {
@@ -312,7 +312,7 @@ class TaskOrchestrator {
     // endregion Single Task
     // region Lifecycle
     async preRunSteps(tasks, metadata) {
-        this.options.lifeCycle.startTasks(tasks, metadata);
+        await this.options.lifeCycle.startTasks(tasks, metadata);
     }
     async postRunSteps(tasks, results, doNotSkipCache, { groupId }) {
         for (const task of tasks) {
@@ -342,7 +342,7 @@ class TaskOrchestrator {
             perf_hooks_1.performance.mark('cache-results-end');
             perf_hooks_1.performance.measure('cache-results', 'cache-results-start', 'cache-results-end');
         }
-        this.options.lifeCycle.endTasks(results.map((result) => {
+        await this.options.lifeCycle.endTasks(results.map((result) => {
             const code = result.status === 'success' ||
                 result.status === 'local-cache' ||
                 result.status === 'local-cache-kept-existing' ||

package/src/utils/git-utils.d.ts

@@ -1,4 +1,4 @@
 export declare function getGithubSlugOrNull(): string | null;
 export declare function extractUserAndRepoFromGitHubUrl(gitRemotes: string): string | null;
-export declare function commitChanges(commitMessage: string): string | null;
+export declare function commitChanges(commitMessage: string, directory?: string): string | null;
 export declare function getLatestCommitSha(): string | null;