@ohos-ports/nx 19.8.4-beta.0

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

@@ -0,0 +1,26 @@
+import { TasksRunner } from './tasks-runner';
+import { LifeCycle } from './life-cycle';
+import { CachedResult } from '../native';
+export interface RemoteCache {
+    retrieve: (hash: string, cacheDirectory: string) => Promise<boolean>;
+    store: (hash: string, cacheDirectory: string) => Promise<boolean>;
+}
+export declare abstract class RemoteCacheV2 {
+    static fromCacheV1(cache: RemoteCache): Promise<RemoteCacheV2>;
+    abstract retrieve(hash: string, cacheDirectory: string): Promise<CachedResult | null>;
+    abstract store(hash: string, cacheDirectory: string, terminalOutput: string, code: number): Promise<boolean>;
+}
+export interface DefaultTasksRunnerOptions {
+    parallel?: number;
+    cacheableOperations?: string[];
+    cacheableTargets?: string[];
+    runtimeCacheInputs?: string[];
+    cacheDirectory?: string;
+    remoteCache?: RemoteCache;
+    lifeCycle: LifeCycle;
+    captureStderr?: boolean;
+    skipNxCache?: boolean;
+    batch?: boolean;
+}
+export declare const defaultTasksRunner: TasksRunner<DefaultTasksRunnerOptions>;
+export default defaultTasksRunner;

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

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultTasksRunner = exports.RemoteCacheV2 = void 0;
+const task_orchestrator_1 = require("./task-orchestrator");
+const cache_directory_1 = require("../utils/cache-directory");
+const promises_1 = require("fs/promises");
+const path_1 = require("path");
+class RemoteCacheV2 {
+    static async fromCacheV1(cache) {
+        await (0, promises_1.mkdir)((0, path_1.join)(cache_directory_1.cacheDir, 'terminalOutputs'), { recursive: true });
+        return {
+            retrieve: async (hash, cacheDirectory) => {
+                const res = await cache.retrieve(hash, cacheDirectory);
+                if (res) {
+                    const [terminalOutput, oldTerminalOutput, code] = await Promise.all([
+                        (0, promises_1.readFile)((0, path_1.join)(cacheDirectory, hash, 'terminalOutputs'), 'utf-8').catch(() => null),
+                        (0, promises_1.readFile)((0, path_1.join)(cache_directory_1.cacheDir, 'terminalOutputs', hash), 'utf-8').catch(() => null),
+                        (0, promises_1.readFile)((0, path_1.join)(cacheDirectory, hash, 'code'), 'utf-8').then((s) => +s),
+                    ]);
+                    return {
+                        outputsPath: cacheDirectory,
+                        terminalOutput: terminalOutput ?? oldTerminalOutput,
+                        code,
+                    };
+                }
+                else {
+                    return null;
+                }
+            },
+            store: async (hash, cacheDirectory, __, code) => {
+                await (0, promises_1.writeFile)((0, path_1.join)(cacheDirectory, hash, 'code'), code.toString());
+                return cache.store(hash, cacheDirectory);
+            },
+        };
+    }
+}
+exports.RemoteCacheV2 = RemoteCacheV2;
+const defaultTasksRunner = async (tasks, options, context) => {
+    if (options['parallel'] === 'false' ||
+        options['parallel'] === false) {
+        options['parallel'] = 1;
+    }
+    else if (options['parallel'] === 'true' ||
+        options['parallel'] === true ||
+        options['parallel'] === undefined ||
+        options['parallel'] === '') {
+        options['parallel'] = Number(options['maxParallel'] || 3);
+    }
+    await options.lifeCycle.startCommand();
+    try {
+        return await runAllTasks(tasks, options, context);
+    }
+    finally {
+        await options.lifeCycle.endCommand();
+    }
+};
+exports.defaultTasksRunner = defaultTasksRunner;
+async function runAllTasks(tasks, options, context) {
+    const orchestrator = new task_orchestrator_1.TaskOrchestrator(context.hasher, context.initiatingProject, context.projectGraph, context.taskGraph, context.nxJson, options, context.nxArgs?.nxBail, context.daemon, context.nxArgs?.outputStyle);
+    return orchestrator.run();
+}
+exports.default = exports.defaultTasksRunner;

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

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

package/src/tasks-runner/fork.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const child_process_1 = require("child_process");
+const path_1 = require("path");
+const pseudo_ipc_1 = require("./pseudo-ipc");
+const pseudoIPCPath = process.argv[2];
+const forkId = process.argv[3];
+const script = (0, path_1.join)(__dirname, '../../bin/run-executor.js');
+let execArgv;
+if (process.env['NX_PSEUDO_TERMINAL_EXEC_ARGV']) {
+    execArgv = process.env['NX_PSEUDO_TERMINAL_EXEC_ARGV'].split('|');
+    delete process.env['NX_PSEUDO_TERMINAL_EXEC_ARGV'];
+}
+const childProcess = (0, child_process_1.fork)(script, {
+    stdio: ['inherit', 'inherit', 'inherit', 'ipc'],
+    env: process.env,
+    execArgv,
+});
+const pseudoIPC = new pseudo_ipc_1.PseudoIPCClient(pseudoIPCPath);
+pseudoIPC.onMessageFromParent(forkId, (message) => {
+    childProcess.send(message);
+});
+pseudoIPC.notifyChildIsReady(forkId);
+process.on('message', (message) => {
+    pseudoIPC.sendMessageToParent(message);
+});
+childProcess.on('exit', (code) => {
+    pseudoIPC.close();
+    process.exit(code);
+});

package/src/tasks-runner/forked-process-task-runner.d.ts

@@ -0,0 +1,42 @@
+import { DefaultTasksRunnerOptions } from './default-tasks-runner';
+import { Batch } from './tasks-schedule';
+import { BatchResults } from './batch/batch-messages';
+import { Task, TaskGraph } from '../config/task-graph';
+export declare class ForkedProcessTaskRunner {
+    private readonly options;
+    cliPath: string;
+    private readonly verbose;
+    private processes;
+    private pseudoTerminal;
+    constructor(options: DefaultTasksRunnerOptions);
+    init(): Promise<void>;
+    forkProcessForBatch({ executorName, taskGraph: batchTaskGraph }: Batch, fullTaskGraph: TaskGraph, env: NodeJS.ProcessEnv): Promise<BatchResults>;
+    forkProcessLegacy(task: Task, { temporaryOutputPath, streamOutput, pipeOutput, taskGraph, env, }: {
+        temporaryOutputPath: string;
+        streamOutput: boolean;
+        pipeOutput: boolean;
+        taskGraph: TaskGraph;
+        env: NodeJS.ProcessEnv;
+    }): Promise<{
+        code: number;
+        terminalOutput: string;
+    }>;
+    forkProcess(task: Task, { temporaryOutputPath, streamOutput, taskGraph, env, disablePseudoTerminal, }: {
+        temporaryOutputPath: string;
+        streamOutput: boolean;
+        pipeOutput: boolean;
+        taskGraph: TaskGraph;
+        env: NodeJS.ProcessEnv;
+        disablePseudoTerminal: boolean;
+    }): Promise<{
+        code: number;
+        terminalOutput: string;
+    }>;
+    private forkProcessWithPseudoTerminal;
+    private forkProcessPipeOutputCapture;
+    private forkProcessWithPrefixAndNotTTY;
+    private forkProcessDirectOutputCapture;
+    private readTerminalOutput;
+    private writeTerminalOutput;
+    private setupProcessEventListeners;
+}

package/src/tasks-runner/forked-process-task-runner.js

@@ -0,0 +1,405 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ForkedProcessTaskRunner = void 0;
+const fs_1 = require("fs");
+const child_process_1 = require("child_process");
+const chalk = require("chalk");
+const logTransformer = require("strong-log-transformer");
+const output_1 = require("../utils/output");
+const utils_1 = require("./utils");
+const path_1 = require("path");
+const batch_messages_1 = require("./batch/batch-messages");
+const strip_indents_1 = require("../utils/strip-indents");
+const stream_1 = require("stream");
+const pseudo_terminal_1 = require("./pseudo-terminal");
+const exit_codes_1 = require("../utils/exit-codes");
+const forkScript = (0, path_1.join)(__dirname, './fork.js');
+const workerPath = (0, path_1.join)(__dirname, './batch/run-batch.js');
+class ForkedProcessTaskRunner {
+    constructor(options) {
+        this.options = options;
+        this.cliPath = (0, utils_1.getCliPath)();
+        this.verbose = process.env.NX_VERBOSE_LOGGING === 'true';
+        this.processes = new Set();
+        this.pseudoTerminal = pseudo_terminal_1.PseudoTerminal.isSupported()
+            ? (0, pseudo_terminal_1.getPseudoTerminal)()
+            : null;
+    }
+    async init() {
+        if (this.pseudoTerminal) {
+            await this.pseudoTerminal.init();
+        }
+        this.setupProcessEventListeners();
+    }
+    // TODO: vsavkin delegate terminal output printing
+    forkProcessForBatch({ executorName, taskGraph: batchTaskGraph }, fullTaskGraph, env) {
+        return new Promise((res, rej) => {
+            try {
+                const count = Object.keys(batchTaskGraph.tasks).length;
+                if (count > 1) {
+                    output_1.output.logSingleLine(`Running ${output_1.output.bold(count)} ${output_1.output.bold('tasks')} with ${output_1.output.bold(executorName)}`);
+                }
+                else {
+                    const args = (0, utils_1.getPrintableCommandArgsForTask)(Object.values(batchTaskGraph.tasks)[0]);
+                    output_1.output.logCommand(args.join(' '));
+                }
+                const p = (0, child_process_1.fork)(workerPath, {
+                    stdio: ['inherit', 'inherit', 'inherit', 'ipc'],
+                    env,
+                });
+                this.processes.add(p);
+                p.once('exit', (code, signal) => {
+                    this.processes.delete(p);
+                    if (code === null)
+                        code = (0, exit_codes_1.signalToCode)(signal);
+                    if (code !== 0) {
+                        const results = {};
+                        for (const rootTaskId of batchTaskGraph.roots) {
+                            results[rootTaskId] = {
+                                success: false,
+                                terminalOutput: '',
+                            };
+                        }
+                        rej(new Error(`"${executorName}" exited unexpectedly with code: ${code}`));
+                    }
+                });
+                p.on('message', (message) => {
+                    switch (message.type) {
+                        case batch_messages_1.BatchMessageType.CompleteBatchExecution: {
+                            res(message.results);
+                            break;
+                        }
+                        case batch_messages_1.BatchMessageType.RunTasks: {
+                            break;
+                        }
+                        default: {
+                            // Re-emit any non-batch messages from the task process
+                            if (process.send) {
+                                process.send(message);
+                            }
+                        }
+                    }
+                });
+                // Start the tasks
+                p.send({
+                    type: batch_messages_1.BatchMessageType.RunTasks,
+                    executorName,
+                    batchTaskGraph,
+                    fullTaskGraph,
+                });
+            }
+            catch (e) {
+                rej(e);
+            }
+        });
+    }
+    async forkProcessLegacy(task, { temporaryOutputPath, streamOutput, pipeOutput, taskGraph, env, }) {
+        return pipeOutput
+            ? await this.forkProcessPipeOutputCapture(task, {
+                temporaryOutputPath,
+                streamOutput,
+                taskGraph,
+                env,
+            })
+            : await this.forkProcessDirectOutputCapture(task, {
+                temporaryOutputPath,
+                streamOutput,
+                taskGraph,
+                env,
+            });
+    }
+    async forkProcess(task, { temporaryOutputPath, streamOutput, taskGraph, env, disablePseudoTerminal, }) {
+        const shouldPrefix = streamOutput && process.env.NX_PREFIX_OUTPUT === 'true';
+        // streamOutput would be false if we are running multiple targets
+        // there's no point in running the commands in a pty if we are not streaming the output
+        if (!this.pseudoTerminal ||
+            disablePseudoTerminal ||
+            !streamOutput ||
+            shouldPrefix) {
+            return this.forkProcessWithPrefixAndNotTTY(task, {
+                temporaryOutputPath,
+                streamOutput,
+                taskGraph,
+                env,
+            });
+        }
+        else {
+            return this.forkProcessWithPseudoTerminal(task, {
+                temporaryOutputPath,
+                streamOutput,
+                taskGraph,
+                env,
+            });
+        }
+    }
+    async forkProcessWithPseudoTerminal(task, { temporaryOutputPath, streamOutput, taskGraph, env, }) {
+        const args = (0, utils_1.getPrintableCommandArgsForTask)(task);
+        if (streamOutput) {
+            output_1.output.logCommand(args.join(' '));
+        }
+        const childId = task.id;
+        const p = await this.pseudoTerminal.fork(childId, forkScript, {
+            cwd: process.cwd(),
+            execArgv: process.execArgv,
+            jsEnv: env,
+            quiet: !streamOutput,
+        });
+        p.send({
+            targetDescription: task.target,
+            overrides: task.overrides,
+            taskGraph,
+            isVerbose: this.verbose,
+        });
+        this.processes.add(p);
+        let terminalOutput = '';
+        p.onOutput((msg) => {
+            terminalOutput += msg;
+        });
+        return new Promise((res) => {
+            p.onExit((code) => {
+                // If the exit code is greater than 128, it's a special exit code for a signal
+                if (code >= 128) {
+                    process.exit(code);
+                }
+                this.writeTerminalOutput(temporaryOutputPath, terminalOutput);
+                res({
+                    code,
+                    terminalOutput,
+                });
+            });
+        });
+    }
+    forkProcessPipeOutputCapture(task, { streamOutput, temporaryOutputPath, taskGraph, env, }) {
+        return this.forkProcessWithPrefixAndNotTTY(task, {
+            streamOutput,
+            temporaryOutputPath,
+            taskGraph,
+            env,
+        });
+    }
+    forkProcessWithPrefixAndNotTTY(task, { streamOutput, temporaryOutputPath, taskGraph, env, }) {
+        return new Promise((res, rej) => {
+            try {
+                const args = (0, utils_1.getPrintableCommandArgsForTask)(task);
+                if (streamOutput) {
+                    output_1.output.logCommand(args.join(' '));
+                }
+                const p = (0, child_process_1.fork)(this.cliPath, {
+                    stdio: ['inherit', 'pipe', 'pipe', 'ipc'],
+                    env,
+                });
+                this.processes.add(p);
+                // Re-emit any messages from the task process
+                p.on('message', (message) => {
+                    if (process.send) {
+                        process.send(message);
+                    }
+                });
+                // Send message to run the executor
+                p.send({
+                    targetDescription: task.target,
+                    overrides: task.overrides,
+                    taskGraph,
+                    isVerbose: this.verbose,
+                });
+                if (streamOutput) {
+                    if (process.env.NX_PREFIX_OUTPUT === 'true') {
+                        const color = getColor(task.target.project);
+                        const prefixText = `${task.target.project}:`;
+                        p.stdout
+                            .pipe(logClearLineToPrefixTransformer(color.bold(prefixText) + ' '))
+                            .pipe(logTransformer({ tag: color.bold(prefixText) }))
+                            .pipe(process.stdout);
+                        p.stderr
+                            .pipe(logClearLineToPrefixTransformer(color(prefixText) + ' '))
+                            .pipe(logTransformer({ tag: color(prefixText) }))
+                            .pipe(process.stderr);
+                    }
+                    else {
+                        p.stdout.pipe(logTransformer()).pipe(process.stdout);
+                        p.stderr.pipe(logTransformer()).pipe(process.stderr);
+                    }
+                }
+                let outWithErr = [];
+                p.stdout.on('data', (chunk) => {
+                    outWithErr.push(chunk.toString());
+                });
+                p.stderr.on('data', (chunk) => {
+                    outWithErr.push(chunk.toString());
+                });
+                p.on('exit', (code, signal) => {
+                    this.processes.delete(p);
+                    if (code === null)
+                        code = (0, exit_codes_1.signalToCode)(signal);
+                    // we didn't print any output as we were running the command
+                    // print all the collected output|
+                    const terminalOutput = outWithErr.join('');
+                    if (!streamOutput) {
+                        this.options.lifeCycle.printTaskTerminalOutput(task, code === 0 ? 'success' : 'failure', terminalOutput);
+                    }
+                    this.writeTerminalOutput(temporaryOutputPath, terminalOutput);
+                    res({ code, terminalOutput });
+                });
+            }
+            catch (e) {
+                console.error(e);
+                rej(e);
+            }
+        });
+    }
+    forkProcessDirectOutputCapture(task, { streamOutput, temporaryOutputPath, taskGraph, env, }) {
+        return new Promise((res, rej) => {
+            try {
+                const args = (0, utils_1.getPrintableCommandArgsForTask)(task);
+                if (streamOutput) {
+                    output_1.output.logCommand(args.join(' '));
+                }
+                const p = (0, child_process_1.fork)(this.cliPath, {
+                    stdio: ['inherit', 'inherit', 'inherit', 'ipc'],
+                    env,
+                });
+                this.processes.add(p);
+                // Re-emit any messages from the task process
+                p.on('message', (message) => {
+                    if (process.send) {
+                        process.send(message);
+                    }
+                });
+                // Send message to run the executor
+                p.send({
+                    targetDescription: task.target,
+                    overrides: task.overrides,
+                    taskGraph,
+                    isVerbose: this.verbose,
+                });
+                p.on('exit', (code, signal) => {
+                    if (code === null)
+                        code = (0, exit_codes_1.signalToCode)(signal);
+                    // we didn't print any output as we were running the command
+                    // print all the collected output
+                    let terminalOutput = '';
+                    try {
+                        terminalOutput = this.readTerminalOutput(temporaryOutputPath);
+                        if (!streamOutput) {
+                            this.options.lifeCycle.printTaskTerminalOutput(task, code === 0 ? 'success' : 'failure', terminalOutput);
+                        }
+                    }
+                    catch (e) {
+                        console.log((0, strip_indents_1.stripIndents) `
+              Unable to print terminal output for Task "${task.id}".
+              Task failed with Exit Code ${code} and Signal "${signal}".
+
+              Received error message:
+              ${e.message}
+            `);
+                    }
+                    res({
+                        code,
+                        terminalOutput,
+                    });
+                });
+            }
+            catch (e) {
+                console.error(e);
+                rej(e);
+            }
+        });
+    }
+    readTerminalOutput(outputPath) {
+        return (0, fs_1.readFileSync)(outputPath).toString();
+    }
+    writeTerminalOutput(outputPath, content) {
+        (0, fs_1.writeFileSync)(outputPath, content);
+    }
+    setupProcessEventListeners() {
+        if (this.pseudoTerminal) {
+            this.pseudoTerminal.onMessageFromChildren((message) => {
+                process.send(message);
+            });
+        }
+        // When the nx process gets a message, it will be sent into the task's process
+        process.on('message', (message) => {
+            // this.publisher.publish(message.toString());
+            if (this.pseudoTerminal) {
+                this.pseudoTerminal.sendMessageToChildren(message);
+            }
+            this.processes.forEach((p) => {
+                if ('connected' in p && p.connected) {
+                    p.send(message);
+                }
+            });
+        });
+        // Terminate any task processes on exit
+        process.on('exit', () => {
+            this.processes.forEach((p) => {
+                if ('connected' in p ? p.connected : p.isAlive) {
+                    p.kill();
+                }
+            });
+        });
+        process.on('SIGINT', () => {
+            this.processes.forEach((p) => {
+                if ('connected' in p ? p.connected : p.isAlive) {
+                    p.kill('SIGTERM');
+                }
+            });
+            // we exit here because we don't need to write anything to cache.
+            process.exit((0, exit_codes_1.signalToCode)('SIGINT'));
+        });
+        process.on('SIGTERM', () => {
+            this.processes.forEach((p) => {
+                if ('connected' in p ? p.connected : p.isAlive) {
+                    p.kill('SIGTERM');
+                }
+            });
+            // no exit here because we expect child processes to terminate which
+            // will store results to the cache and will terminate this process
+        });
+        process.on('SIGHUP', () => {
+            this.processes.forEach((p) => {
+                if ('connected' in p ? p.connected : p.isAlive) {
+                    p.kill('SIGTERM');
+                }
+            });
+            // no exit here because we expect child processes to terminate which
+            // will store results to the cache and will terminate this process
+        });
+    }
+}
+exports.ForkedProcessTaskRunner = ForkedProcessTaskRunner;
+const colors = [
+    chalk.green,
+    chalk.greenBright,
+    chalk.red,
+    chalk.redBright,
+    chalk.cyan,
+    chalk.cyanBright,
+    chalk.yellow,
+    chalk.yellowBright,
+    chalk.magenta,
+    chalk.magentaBright,
+];
+function getColor(projectName) {
+    let code = 0;
+    for (let i = 0; i < projectName.length; ++i) {
+        code += projectName.charCodeAt(i);
+    }
+    const colorIndex = code % colors.length;
+    return colors[colorIndex];
+}
+/**
+ * Prevents terminal escape sequence from clearing line prefix.
+ */
+function logClearLineToPrefixTransformer(prefix) {
+    let prevChunk = null;
+    return new stream_1.Transform({
+        transform(chunk, _encoding, callback) {
+            if (prevChunk && prevChunk.toString() === '\x1b[2K') {
+                chunk = chunk.toString().replace(/\x1b\[1G/g, (m) => m + prefix);
+            }
+            this.push(chunk);
+            prevChunk = chunk;
+            callback();
+        },
+    });
+}

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

@@ -0,0 +1,13 @@
+import { NxArgs } from '../utils/command-line-utils';
+import { Task, TaskGraph } from '../config/task-graph';
+import { TaskResult } from './life-cycle';
+export declare function initTasksRunner(nxArgs: NxArgs): Promise<{
+    invoke: (opts: {
+        tasks: Task[];
+        parallel: number;
+    }) => Promise<{
+        status: NodeJS.Process["exitCode"];
+        taskGraph: TaskGraph;
+        taskResults: Record<string, TaskResult>;
+    }>;
+}>;

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

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initTasksRunner = initTasksRunner;
+const workspace_configuration_check_1 = require("../utils/workspace-configuration-check");
+const configuration_1 = require("../config/configuration");
+const project_graph_1 = require("../project-graph/project-graph");
+const run_command_1 = require("./run-command");
+const invoke_runner_terminal_output_life_cycle_1 = require("./life-cycles/invoke-runner-terminal-output-life-cycle");
+const perf_hooks_1 = require("perf_hooks");
+const utils_1 = require("./utils");
+const dotenv_1 = require("../utils/dotenv");
+async function initTasksRunner(nxArgs) {
+    perf_hooks_1.performance.mark('init-local');
+    (0, dotenv_1.loadRootEnvFiles)();
+    (0, workspace_configuration_check_1.workspaceConfigurationCheck)();
+    const nxJson = (0, configuration_1.readNxJson)();
+    if (nxArgs.verbose) {
+        process.env.NX_VERBOSE_LOGGING = 'true';
+    }
+    const projectGraph = await (0, project_graph_1.createProjectGraphAsync)({ exitOnError: true });
+    return {
+        invoke: async (opts) => {
+            perf_hooks_1.performance.mark('code-loading:end');
+            // TODO: This polyfills the outputs if someone doesn't pass a task with outputs. Remove this in Nx 20
+            opts.tasks.forEach((t) => {
+                if (!t.outputs) {
+                    t.outputs = (0, utils_1.getOutputs)(projectGraph.nodes, t.target, t.overrides);
+                }
+            });
+            const lifeCycle = new invoke_runner_terminal_output_life_cycle_1.InvokeRunnerTerminalOutputLifeCycle(opts.tasks);
+            const taskGraph = {
+                roots: opts.tasks.map((task) => task.id),
+                tasks: opts.tasks.reduce((acc, task) => {
+                    acc[task.id] = task;
+                    return acc;
+                }, {}),
+                dependencies: opts.tasks.reduce((acc, task) => {
+                    acc[task.id] = [];
+                    return acc;
+                }, {}),
+            };
+            const taskResults = await (0, run_command_1.invokeTasksRunner)({
+                tasks: opts.tasks,
+                projectGraph,
+                taskGraph,
+                lifeCycle,
+                nxJson,
+                nxArgs: { ...nxArgs, parallel: opts.parallel },
+                loadDotEnvFiles: true,
+                initiatingProject: null,
+            });
+            return {
+                status: Object.values(taskResults).some((taskResult) => taskResult.status === 'failure' || taskResult.status === 'skipped')
+                    ? 1
+                    : 0,
+                taskGraph,
+                taskResults,
+            };
+        },
+    };
+}