@depup/nx 22.5.4-depup.0

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

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEnvVariablesForBatchProcess = getEnvVariablesForBatchProcess;
+exports.getTaskSpecificEnv = getTaskSpecificEnv;
+exports.getEnvVariablesForTask = getEnvVariablesForTask;
+exports.loadAndExpandDotEnvFile = loadAndExpandDotEnvFile;
+exports.unloadDotEnvFile = unloadDotEnvFile;
+exports.getEnvFilesForTask = getEnvFilesForTask;
+const dotenv_1 = require("dotenv");
+const dotenv_expand_1 = require("dotenv-expand");
+const workspace_root_1 = require("../utils/workspace-root");
+const node_path_1 = require("node:path");
+const task_env_paths_1 = require("./task-env-paths");
+function getEnvVariablesForBatchProcess(skipNxCache, captureStderr) {
+    return {
+        // User Process Env Variables override Dotenv Variables
+        ...process.env,
+        // Nx Env Variables overrides everything
+        ...getNxEnvVariablesForForkedProcess(process.env.FORCE_COLOR === undefined ? 'true' : process.env.FORCE_COLOR, skipNxCache, captureStderr),
+    };
+}
+function getTaskSpecificEnv(task, graph) {
+    // Unload any dot env files at the root of the workspace that were loaded on init of Nx.
+    const taskEnv = unloadDotEnvFiles({ ...process.env });
+    return process.env.NX_LOAD_DOT_ENV_FILES === 'true'
+        ? loadDotEnvFilesForTask(task, graph, taskEnv)
+        : // If not loading dot env files, ensure env vars created by system are still loaded
+            taskEnv;
+}
+function getEnvVariablesForTask(task, taskSpecificEnv, forceColor, skipNxCache, captureStderr, outputPath, streamOutput) {
+    const res = {
+        // Start With Dotenv Variables
+        ...taskSpecificEnv,
+        // Nx Env Variables overrides everything
+        ...getNxEnvVariablesForTask(task, forceColor, skipNxCache, captureStderr, outputPath, streamOutput),
+    };
+    // we have to delete it because if we invoke Nx from within Nx, we need to reset those values
+    if (!outputPath) {
+        delete res.NX_TERMINAL_OUTPUT_PATH;
+        delete res.NX_STREAM_OUTPUT;
+        delete res.NX_PREFIX_OUTPUT;
+    }
+    // we don't reset NX_BASE or NX_HEAD because those are set by the user and should be preserved
+    delete res.NX_SET_CLI;
+    return res;
+}
+function getNxEnvVariablesForForkedProcess(forceColor, skipNxCache, captureStderr, outputPath, streamOutput) {
+    const env = {
+        FORCE_COLOR: forceColor,
+        NX_WORKSPACE_ROOT: workspace_root_1.workspaceRoot,
+        NX_SKIP_NX_CACHE: skipNxCache ? 'true' : undefined,
+    };
+    if (outputPath) {
+        env.NX_TERMINAL_OUTPUT_PATH = outputPath;
+        if (captureStderr) {
+            env.NX_TERMINAL_CAPTURE_STDERR = 'true';
+        }
+        if (streamOutput) {
+            env.NX_STREAM_OUTPUT = 'true';
+        }
+    }
+    return env;
+}
+function getNxEnvVariablesForTask(task, forceColor, skipNxCache, captureStderr, outputPath, streamOutput) {
+    const env = {
+        NX_TASK_TARGET_PROJECT: task.target.project,
+        NX_TASK_TARGET_TARGET: task.target.target,
+        NX_TASK_TARGET_CONFIGURATION: task.target.configuration ?? undefined,
+        NX_TASK_HASH: task.hash,
+        // used when Nx is invoked via Lerna
+        LERNA_PACKAGE_NAME: task.target.project,
+    };
+    // TODO: remove this once we have a reasonable way to configure it
+    if (task.target.target === 'test') {
+        env.NX_TERMINAL_CAPTURE_STDERR = 'true';
+    }
+    return {
+        ...getNxEnvVariablesForForkedProcess(forceColor, skipNxCache, captureStderr, outputPath, streamOutput),
+        ...env,
+        // Ensure the TUI does not get spawned within the TUI if ever tasks invoke Nx again
+        NX_TUI: 'false',
+    };
+}
+/**
+ * This function loads a .env file and expands the variables in it.
+ * @param filename the .env file to load
+ * @param environmentVariables the object to load environment variables into
+ * @param override whether to override existing environment variables
+ */
+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,
+    });
+}
+/**
+ * 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];
+        }
+    });
+}
+function getOwnerTargetForTask(task, graph) {
+    const project = graph.nodes[task.target.project];
+    if (project.data.metadata?.targetGroups) {
+        for (const targets of Object.values(project.data.metadata.targetGroups)) {
+            if (targets.includes(task.target.target)) {
+                for (const target of targets) {
+                    if (project.data.targets[target].metadata?.nonAtomizedTarget) {
+                        return [
+                            target,
+                            project.data.targets[target].metadata?.nonAtomizedTarget,
+                        ];
+                    }
+                }
+            }
+        }
+    }
+    return [task.target.target];
+}
+function getEnvFilesForTask(task, graph) {
+    const [target, nonAtomizedTarget] = getOwnerTargetForTask(task, graph);
+    return (0, task_env_paths_1.getEnvPathsForTask)(task.projectRoot, target, task.target.configuration, nonAtomizedTarget);
+}
+function loadDotEnvFilesForTask(task, graph, environmentVariables) {
+    const dotEnvFiles = getEnvFilesForTask(task, graph);
+    for (const file of dotEnvFiles) {
+        loadAndExpandDotEnvFile((0, node_path_1.join)(workspace_root_1.workspaceRoot, file), environmentVariables);
+    }
+    return environmentVariables;
+}
+function unloadDotEnvFiles(environmentVariables) {
+    for (const file of ['.env', '.local.env', '.env.local']) {
+        unloadDotEnvFile((0, node_path_1.join)(workspace_root_1.workspaceRoot, file), environmentVariables);
+    }
+    return environmentVariables;
+}

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

@@ -0,0 +1,26 @@
+import { ProjectGraph } from '../config/project-graph';
+import { TaskGraph } from '../config/task-graph';
+/**
+ * This function finds a cycle in the graph.
+ * @returns the first cycle found, or null if no cycle is found.
+ */
+export declare function findCycle(graph: {
+    dependencies: Record<string, string[]>;
+    continuousDependencies?: Record<string, string[]>;
+}): string[] | null;
+/**
+ * This function finds all cycles in the graph.
+ * @returns a list of unique task ids in all cycles found, or null if no cycle is found.
+ */
+export declare function findCycles(graph: {
+    dependencies: Record<string, string[]>;
+    continuousDependencies?: Record<string, string[]>;
+}): Set<string> | null;
+export declare function makeAcyclic(graph: {
+    roots: string[];
+    dependencies: Record<string, string[]>;
+}): void;
+export declare function validateNoAtomizedTasks(taskGraph: TaskGraph, projectGraph: ProjectGraph): void;
+export declare function assertTaskGraphDoesNotContainInvalidTargets(taskGraph: TaskGraph): void;
+export declare function getLeafTasks(taskGraph: TaskGraph): Set<string>;
+//# sourceMappingURL=task-graph-utils.d.ts.map

package/src/tasks-runner/task-graph-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-graph-utils.d.ts","sourceRoot":"","sources":["../../../../../packages/nx/src/tasks-runner/task-graph-utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AACvD,OAAO,EAAQ,SAAS,EAAE,MAAM,sBAAsB,CAAC;AA0BvD;;;GAGG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE;IAC/B,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;IACvC,sBAAsB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;CACnD,GAAG,MAAM,EAAE,GAAG,IAAI,CAYlB;AAED;;;GAGG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE;IAChC,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;IACvC,sBAAsB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;CACnD,GAAG,GAAG,CAAC,MAAM,CAAC,GAAG,IAAI,CAerB;AAiCD,wBAAgB,WAAW,CAAC,KAAK,EAAE;IACjC,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;CACxC,GAAG,IAAI,CAWP;AAED,wBAAgB,uBAAuB,CACrC,SAAS,EAAE,SAAS,EACpB,YAAY,EAAE,YAAY,QAyC3B;AAED,wBAAgB,2CAA2C,CACzD,SAAS,EAAE,SAAS,QAgCrB;AA8CD,wBAAgB,YAAY,CAAC,SAAS,EAAE,SAAS,GAAG,GAAG,CAAC,MAAM,CAAC,CAU9D"}

package/src/tasks-runner/task-graph-utils.js

@@ -0,0 +1,197 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findCycle = findCycle;
+exports.findCycles = findCycles;
+exports.makeAcyclic = makeAcyclic;
+exports.validateNoAtomizedTasks = validateNoAtomizedTasks;
+exports.assertTaskGraphDoesNotContainInvalidTargets = assertTaskGraphDoesNotContainInvalidTargets;
+exports.getLeafTasks = getLeafTasks;
+const output_1 = require("../utils/output");
+function _findCycle(graph, id, visited, path) {
+    if (visited[id])
+        return null;
+    visited[id] = true;
+    for (const d of [
+        ...graph.dependencies[id],
+        ...(graph.continuousDependencies?.[id] ?? []),
+    ]) {
+        if (path.includes(d))
+            return [...path, d];
+        const cycle = _findCycle(graph, d, visited, [...path, d]);
+        if (cycle)
+            return cycle;
+    }
+    return null;
+}
+/**
+ * This function finds a cycle in the graph.
+ * @returns the first cycle found, or null if no cycle is found.
+ */
+function findCycle(graph) {
+    const visited = {};
+    for (const t of Object.keys(graph.dependencies)) {
+        visited[t] = false;
+    }
+    for (const t of Object.keys(graph.dependencies)) {
+        const cycle = _findCycle(graph, t, visited, [t]);
+        if (cycle)
+            return cycle;
+    }
+    return null;
+}
+/**
+ * This function finds all cycles in the graph.
+ * @returns a list of unique task ids in all cycles found, or null if no cycle is found.
+ */
+function findCycles(graph) {
+    const visited = {};
+    const cycles = new Set();
+    for (const t of Object.keys(graph.dependencies)) {
+        visited[t] = false;
+    }
+    for (const t of Object.keys(graph.dependencies)) {
+        const cycle = _findCycle(graph, t, visited, [t]);
+        if (cycle) {
+            cycle.forEach((t) => cycles.add(t));
+        }
+    }
+    return cycles.size ? cycles : null;
+}
+function _makeAcyclic(graph, id, visited, path) {
+    if (visited[id])
+        return;
+    visited[id] = true;
+    const deps = graph.dependencies[id];
+    const continuousDeps = graph.continuousDependencies?.[id] ?? [];
+    for (const d of [...deps, ...continuousDeps]) {
+        if (path.includes(d)) {
+            const depsIdx = deps.indexOf(d);
+            if (depsIdx >= 0) {
+                deps.splice(depsIdx, 1);
+            }
+            const continuousIdx = continuousDeps.indexOf(d);
+            if (continuousIdx >= 0) {
+                continuousDeps.splice(continuousIdx, 1);
+            }
+        }
+        else {
+            _makeAcyclic(graph, d, visited, [...path, d]);
+        }
+    }
+    return null;
+}
+function makeAcyclic(graph) {
+    const visited = {};
+    for (const t of Object.keys(graph.dependencies)) {
+        visited[t] = false;
+    }
+    for (const t of Object.keys(graph.dependencies)) {
+        _makeAcyclic(graph, t, visited, [t]);
+    }
+    graph.roots = Object.keys(graph.dependencies).filter((t) => graph.dependencies[t].length === 0);
+}
+function validateNoAtomizedTasks(taskGraph, projectGraph) {
+    const getNonAtomizedTargetForTask = (task) => projectGraph.nodes[task.target.project]?.data?.targets?.[task.target.target]
+        ?.metadata?.nonAtomizedTarget;
+    const atomizedRootTasks = Object.values(taskGraph.tasks).filter((task) => getNonAtomizedTargetForTask(task) !== undefined);
+    if (atomizedRootTasks.length === 0) {
+        return;
+    }
+    const nonAtomizedTasks = atomizedRootTasks
+        .map((t) => `"${getNonAtomizedTargetForTask(t)}"`)
+        .filter((item, index, arr) => arr.indexOf(item) === index);
+    const moreInfoLines = [
+        `Please enable Nx Cloud or use the slower ${nonAtomizedTasks.join(',')} task${nonAtomizedTasks.length > 1 ? 's' : ''}.`,
+        'Learn more at https://nx.dev/ci/features/split-e2e-tasks#nx-cloud-is-required-to-run-atomized-tasks',
+    ];
+    if (atomizedRootTasks.length === 1) {
+        output_1.output.error({
+            title: `The ${atomizedRootTasks[0].id} task should only be run with Nx Cloud.`,
+            bodyLines: [...moreInfoLines],
+        });
+    }
+    else {
+        output_1.output.error({
+            title: `The following tasks should only be run with Nx Cloud:`,
+            bodyLines: [
+                ...atomizedRootTasks.map((task) => `  - ${task.id}`),
+                '',
+                ...moreInfoLines,
+            ],
+        });
+    }
+    process.exit(1);
+}
+function assertTaskGraphDoesNotContainInvalidTargets(taskGraph) {
+    const nonParallelTasksThatDependOnContinuousTasks = [];
+    const nonParallelContinuousTasksThatAreDependedOn = [];
+    for (const task of Object.values(taskGraph.tasks)) {
+        if (task.parallelism === false &&
+            taskGraph.continuousDependencies[task.id].length > 0) {
+            nonParallelTasksThatDependOnContinuousTasks.push(task);
+        }
+        for (const dependency of taskGraph.continuousDependencies[task.id]) {
+            if (taskGraph.tasks[dependency].parallelism === false) {
+                nonParallelContinuousTasksThatAreDependedOn.push(taskGraph.tasks[dependency]);
+            }
+        }
+    }
+    if (nonParallelTasksThatDependOnContinuousTasks.length > 0) {
+        throw new NonParallelTaskDependsOnContinuousTasksError(nonParallelTasksThatDependOnContinuousTasks, taskGraph);
+    }
+    if (nonParallelContinuousTasksThatAreDependedOn.length > 0) {
+        throw new DependingOnNonParallelContinuousTaskError(nonParallelContinuousTasksThatAreDependedOn, taskGraph);
+    }
+}
+class NonParallelTaskDependsOnContinuousTasksError extends Error {
+    constructor(invalidTasks, taskGraph) {
+        let message = 'The following tasks do not support parallelism but depend on continuous tasks:';
+        for (const task of invalidTasks) {
+            message += `\n - ${task.id} -> ${taskGraph.continuousDependencies[task.id].join(', ')}`;
+        }
+        super(message);
+        this.invalidTasks = invalidTasks;
+        this.name = 'NonParallelTaskDependsOnContinuousTasksError';
+    }
+}
+class DependingOnNonParallelContinuousTaskError extends Error {
+    constructor(invalidTasks, taskGraph) {
+        let message = 'The following continuous tasks do not support parallelism but are depended on:';
+        for (const task of invalidTasks) {
+            const dependents = Object.keys(taskGraph.continuousDependencies).filter((parentTaskId) => taskGraph.continuousDependencies[parentTaskId].includes(task.id));
+            message += `\n - ${task.id} <- ${dependents.join(', ')}`;
+        }
+        message +=
+            '\nParallelism must be enabled for a continuous task if it is depended on, as the tasks that depend on it will run in parallel with it.';
+        super(message);
+        this.invalidTasks = invalidTasks;
+        this.name = 'DependingOnNonParallelContinuousTaskError';
+    }
+}
+function getLeafTasks(taskGraph) {
+    const reversed = reverseTaskGraph(taskGraph);
+    const leafTasks = new Set();
+    for (const [taskId, dependencies] of Object.entries(reversed.dependencies)) {
+        if (dependencies.length === 0) {
+            leafTasks.add(taskId);
+        }
+    }
+    return leafTasks;
+}
+function reverseTaskGraph(taskGraph) {
+    const reversed = {
+        tasks: taskGraph.tasks,
+        dependencies: Object.fromEntries(Object.entries(taskGraph.tasks).map(([taskId]) => [taskId, []])),
+    };
+    for (const [taskId, dependencies] of Object.entries(taskGraph.dependencies)) {
+        for (const dependency of dependencies) {
+            reversed.dependencies[dependency].push(taskId);
+        }
+    }
+    for (const [taskId, dependencies] of Object.entries(taskGraph.continuousDependencies)) {
+        for (const dependency of dependencies) {
+            reversed.dependencies[dependency].push(taskId);
+        }
+    }
+    return reversed;
+}

package/src/tasks-runner/task-io-service.d.ts

@@ -0,0 +1,97 @@
+import { ProjectGraph } from '../config/project-graph';
+import { TaskGraph } from '../config/task-graph';
+/**
+ * Maps taskId -> PID. Note that this only Returns
+ * the PID that the main task process is running under,
+ * not any child processes it may have spawned. To fully
+ * trace the task's processes, you'll need to correlate
+ * spawned processes's PIDs with their parent PID.
+ */
+export type TaskPidUpdate = {
+    taskId: string;
+    pid: number;
+};
+export type TaskPidCallback = (update: TaskPidUpdate) => void;
+export type TaskInputInfo = {
+    taskId: string;
+    inputs: {
+        files: string[];
+        runtime: string[];
+        environment: string[];
+        depOutputs: string[];
+        external: string[];
+    };
+};
+export type TaskInputCallback = (taskInputInfo: TaskInputInfo) => void;
+export type TaskOutputsUpdate = {
+    taskId: string;
+    outputs: string[];
+};
+export type TaskOutputsCallback = (update: TaskOutputsUpdate) => void;
+/**
+ * Service for tracking task process IDs and providing access to task IO information.
+ * Subscribes to ProcessMetricsService for PID discovery.
+ * IO information comes from hash inputs (populated during hashing).
+ * Output files are reported when tasks are stored to cache.
+ */
+declare class TaskIOService {
+    protected taskToPids: Map<string, number>;
+    protected taskToInputs: Map<string, TaskInputInfo>;
+    protected taskToOutputs: Map<string, string[]>;
+    private pidCallbacks;
+    private taskInputCallbacks;
+    private taskOutputsCallbacks;
+    protected projectGraph: ProjectGraph | null;
+    protected taskGraph: TaskGraph | null;
+    constructor(projectGraph?: ProjectGraph, taskGraph?: TaskGraph);
+    /**
+     * Subscribe to task PID updates.
+     * Receives notifications when processes are added/removed from tasks.
+     */
+    subscribeToTaskPids(callback: TaskPidCallback): void;
+    /**
+     * Subscribe to hash inputs as they are computed.
+     * Called when a task's hash inputs become available.
+     */
+    subscribeToTaskInputs(callback: TaskInputCallback): void;
+    /**
+     * Subscribe to task outputs as they are stored to cache.
+     * Called when a task's output files are collected for caching.
+     */
+    subscribeToTaskOutputs(callback: TaskOutputsCallback): void;
+    /**
+     * Notify subscribers that hash inputs are available for a task.
+     * Called from the hasher when inputs are computed.
+     */
+    notifyTaskInputs(taskId: string, inputs: {
+        files: string[];
+        runtime: string[];
+        environment: string[];
+        depOutputs: string[];
+        external: string[];
+    }): void;
+    /**
+     * Notify subscribers that task outputs have been collected.
+     * Called from the cache when outputs are stored.
+     */
+    notifyTaskOutputs(taskId: string, outputs: string[]): void;
+    /**
+     * Registers a PID to a task and notifies subscribers.
+     * @param update The TaskPidUpdate containing taskId and pid.
+     */
+    notifyPidUpdate(update: TaskPidUpdate): void;
+}
+/**
+ * Get or create the singleton TaskIOService instance.
+ * Optionally provide projectGraph and taskGraph to initialize with context.
+ */
+export declare function getTaskIOService(projectGraph?: ProjectGraph, taskGraph?: TaskGraph): TaskIOService;
+/**
+ * Register a task process start with both IO and metrics services.
+ * This is the standard way to notify the system that a task process has started.
+ * Both services need to be notified together - TaskIOService for external subscribers
+ * and ProcessMetricsService for native resource monitoring.
+ */
+export declare function registerTaskProcessStart(taskId: string, pid: number): void;
+export {};
+//# sourceMappingURL=task-io-service.d.ts.map

package/src/tasks-runner/task-io-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-io-service.d.ts","sourceRoot":"","sources":["../../../../../packages/nx/src/tasks-runner/task-io-service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AACvD,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAGjD;;;;;;GAMG;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;CACb,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG,CAAC,MAAM,EAAE,aAAa,KAAK,IAAI,CAAC;AAE9D,MAAM,MAAM,aAAa,GAAG;IAC1B,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE;QACN,KAAK,EAAE,MAAM,EAAE,CAAC;QAChB,OAAO,EAAE,MAAM,EAAE,CAAC;QAClB,WAAW,EAAE,MAAM,EAAE,CAAC;QACtB,UAAU,EAAE,MAAM,EAAE,CAAC;QACrB,QAAQ,EAAE,MAAM,EAAE,CAAC;KACpB,CAAC;CACH,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG,CAAC,aAAa,EAAE,aAAa,KAAK,IAAI,CAAC;AAEvE,MAAM,MAAM,iBAAiB,GAAG;IAC9B,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG,CAAC,MAAM,EAAE,iBAAiB,KAAK,IAAI,CAAC;AAEtE;;;;;GAKG;AACH,cAAM,aAAa;IAEjB,SAAS,CAAC,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAa;IACtD,SAAS,CAAC,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,CAAa;IAC/D,SAAS,CAAC,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAa;IAG3D,OAAO,CAAC,YAAY,CAAyB;IAC7C,OAAO,CAAC,kBAAkB,CAA2B;IACrD,OAAO,CAAC,oBAAoB,CAA6B;IAGzD,SAAS,CAAC,YAAY,EAAE,YAAY,GAAG,IAAI,CAAQ;IACnD,SAAS,CAAC,SAAS,EAAE,SAAS,GAAG,IAAI,CAAQ;gBAEjC,YAAY,CAAC,EAAE,YAAY,EAAE,SAAS,CAAC,EAAE,SAAS;IAS9D;;;OAGG;IACH,mBAAmB,CAAC,QAAQ,EAAE,eAAe,GAAG,IAAI;IAYpD;;;OAGG;IACH,qBAAqB,CAAC,QAAQ,EAAE,iBAAiB,GAAG,IAAI;IASxD;;;OAGG;IACH,sBAAsB,CAAC,QAAQ,EAAE,mBAAmB,GAAG,IAAI;IAY3D;;;OAGG;IACH,gBAAgB,CACd,MAAM,EAAE,MAAM,EACd,MAAM,EAAE;QACN,KAAK,EAAE,MAAM,EAAE,CAAC;QAChB,OAAO,EAAE,MAAM,EAAE,CAAC;QAClB,WAAW,EAAE,MAAM,EAAE,CAAC;QACtB,UAAU,EAAE,MAAM,EAAE,CAAC;QACrB,QAAQ,EAAE,MAAM,EAAE,CAAC;KACpB,GACA,IAAI;IAgBP;;;OAGG;IACH,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI;IAiB1D;;;OAGG;IACH,eAAe,CAAC,MAAM,EAAE,aAAa,GAAG,IAAI;CAU7C;AAKD;;;GAGG;AACH,wBAAgB,gBAAgB,CAC9B,YAAY,CAAC,EAAE,YAAY,EAC3B,SAAS,CAAC,EAAE,SAAS,GACpB,aAAa,CAKf;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI,CAG1E"}

package/src/tasks-runner/task-io-service.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTaskIOService = getTaskIOService;
+exports.registerTaskProcessStart = registerTaskProcessStart;
+const process_metrics_service_1 = require("./process-metrics-service");
+/**
+ * Service for tracking task process IDs and providing access to task IO information.
+ * Subscribes to ProcessMetricsService for PID discovery.
+ * IO information comes from hash inputs (populated during hashing).
+ * Output files are reported when tasks are stored to cache.
+ */
+class TaskIOService {
+    constructor(projectGraph, taskGraph) {
+        // Used to call subscribers that were late to the party
+        this.taskToPids = new Map();
+        this.taskToInputs = new Map();
+        this.taskToOutputs = new Map();
+        // Subscription state
+        this.pidCallbacks = [];
+        this.taskInputCallbacks = [];
+        this.taskOutputsCallbacks = [];
+        // Project graph and task graph for resolving task information
+        this.projectGraph = null;
+        this.taskGraph = null;
+        if (projectGraph) {
+            this.projectGraph = projectGraph;
+        }
+        if (taskGraph) {
+            this.taskGraph = taskGraph;
+        }
+    }
+    /**
+     * Subscribe to task PID updates.
+     * Receives notifications when processes are added/removed from tasks.
+     */
+    subscribeToTaskPids(callback) {
+        this.pidCallbacks.push(callback);
+        // Emit current state to new subscriber
+        for (const [taskId, pid] of this.taskToPids) {
+            callback({
+                taskId,
+                pid,
+            });
+        }
+    }
+    /**
+     * Subscribe to hash inputs as they are computed.
+     * Called when a task's hash inputs become available.
+     */
+    subscribeToTaskInputs(callback) {
+        this.taskInputCallbacks.push(callback);
+        // Emit current state to new subscriber
+        for (const [, taskInputInfo] of this.taskToInputs) {
+            callback(taskInputInfo);
+        }
+    }
+    /**
+     * Subscribe to task outputs as they are stored to cache.
+     * Called when a task's output files are collected for caching.
+     */
+    subscribeToTaskOutputs(callback) {
+        this.taskOutputsCallbacks.push(callback);
+        // Emit current state to new subscriber
+        for (const [task, outputs] of this.taskToOutputs) {
+            callback({
+                taskId: task,
+                outputs: outputs,
+            });
+        }
+    }
+    /**
+     * Notify subscribers that hash inputs are available for a task.
+     * Called from the hasher when inputs are computed.
+     */
+    notifyTaskInputs(taskId, inputs) {
+        const taskInputInfo = {
+            taskId,
+            inputs,
+        };
+        this.taskToInputs.set(taskId, taskInputInfo);
+        for (const cb of this.taskInputCallbacks) {
+            try {
+                cb(taskInputInfo);
+            }
+            catch {
+                // Silent failure - don't let one callback break others
+            }
+        }
+    }
+    /**
+     * Notify subscribers that task outputs have been collected.
+     * Called from the cache when outputs are stored.
+     */
+    notifyTaskOutputs(taskId, outputs) {
+        this.taskToOutputs.set(taskId, outputs);
+        const update = {
+            taskId,
+            outputs,
+        };
+        for (const cb of this.taskOutputsCallbacks) {
+            try {
+                cb(update);
+            }
+            catch {
+                // Silent failure - don't let one callback break others
+            }
+        }
+    }
+    /**
+     * Registers a PID to a task and notifies subscribers.
+     * @param update The TaskPidUpdate containing taskId and pid.
+     */
+    notifyPidUpdate(update) {
+        this.taskToPids.set(update.taskId, update.pid);
+        for (const cb of this.pidCallbacks) {
+            try {
+                cb(update);
+            }
+            catch {
+                // Silent failure - don't let one callback break others
+            }
+        }
+    }
+}
+// Singleton
+let instance = null;
+/**
+ * Get or create the singleton TaskIOService instance.
+ * Optionally provide projectGraph and taskGraph to initialize with context.
+ */
+function getTaskIOService(projectGraph, taskGraph) {
+    if (!instance) {
+        instance = new TaskIOService(projectGraph, taskGraph);
+    }
+    return instance;
+}
+/**
+ * Register a task process start with both IO and metrics services.
+ * This is the standard way to notify the system that a task process has started.
+ * Both services need to be notified together - TaskIOService for external subscribers
+ * and ProcessMetricsService for native resource monitoring.
+ */
+function registerTaskProcessStart(taskId, pid) {
+    getTaskIOService().notifyPidUpdate({ taskId, pid });
+    (0, process_metrics_service_1.getProcessMetricsService)().registerTaskProcess(taskId, pid);
+}